Write a function that combines two lists by zipping two lists togeth.pdf
•
0 likes•2 views
Write a function that combines two lists by zipping two lists together. Zipping is defined as taking one node from one list and then one from the other list and so on in order to form a single list. After execution, the first list in the original call should point to the combined list (function name: Zip) Solution Hi, Please find my implementation. Please let me know in case of any issue: Node* Zip(Node *head1, Node *head2){ // base case, if head1 is NULL if(head1 == NULL) return head2; // if head2 is NULL if(head2 == NULL) return head1; Node *newHead = NULL; Node current = NULL; // initializing newHead with head1 newHead = head1; // poiniting to head1 newHead->next = head2; current = head2; // forwarding one step head1 = head1->next; head2 = head2->next; while(head1 != NULL && head2 != NULL){ current->next = head1; current->next->next = head2; current = head2; head1 = head1->next; head2 = head2->next; } // copying remaining nodes from head1, if any while(head1 != NULL){ current->next = head1; current = head1; head1 = head1->next; } // copying remaining nodes from head2, if any while(head2 != NULL){ current->next = head2; current = head2; head2 = head2->next; } return newHead; }.
Report
Share
Report
Share
Download to read offline
Recommended
using the single linked list code written in the class or in the lab,.pdf
using the single linked list code written in the class or in the lab, write and test the follow
function: Merge() function that takes two lists, each of which is sorted in increasing order, and
merges the two together into one list which is in increasing order.
Solution
//The main class
class MergeList {
Node head; // head of list
static Node a, b;
//Node class
static class Node {
int element;
Node next;
// Constructor to create a new node
Node(int d) {
element = d;
next = null;
}
}
void printlist(Node node) {
while (node != null) {
System.out.print(node.element + \" \");
node = node.next;
}
}
Node sortMerge(Node node1, Node node2) {
// Here we will check whether both the list are null or not.
if (node1 == null && node2 == null) {
return null;
}
// sortResultant node
Node sortRes = null;
// Now we will compare and merge the elements of both the list.
while (node1 != null && node2 != null) {
// We will compare current element of both lists
if (node1.element >= node2.element) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
} else {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
}
// If second list reached end, but first list has
// nodes. Add remaining nodes of first list at the
// front of sortResult list
while (node1 != null) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
}
// If first list reached end, but second list has
// node. Add remaining nodes of first list at the
// front of sortResult list
while (node2 != null) {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
return sortRes;
}
public static void main(String[] args) {
MergeList list = new MergeList();
Node sortResult = null;
//Create two linked list
list.a = new Node(5);
list.a.next = new Node(10);
list.a.next.next = new Node(15);
list.b = new Node(2);
list.b.next = new Node(3);
list.b.next.next = new Node(20);
System.out.println(\"List a before merge :\");
list.printlist(a);
System.out.println(\"\");
System.out.println(\"List b before merge :\");
list.printlist(b);
// Cal the function to merge the list in increasing order.
sortResult = list.sortedmerge(a, b);
System.out.println(\"\");
System.out.println(\"Merged linked list : \");
list.printlist(sortResult);
}
}.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
c++ Computational Complexity filling in the following three .pdf
c++ Computational Complexity
/* filling in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
should output
* \"HEAD->1->2->3->NULL\"
*
* 2) Node* add(Node* head, int data)
* Given the old head pointer to a list, create a new node using the value of data, and add the new
node to the front of
* the list. Return the new head pointer.
* Example: If the original list is \"HEAD->1->2->NULL\", then after adding 5, it should
become \"HEAD->5->1->2->NULL\". The
* return value should be the address of node 5.
*
* 3) void magic(Node* p1, Node* p2)
* p1 and p2 each points to a node from a same list. p1 may point to a later node than p2. Your
task is to calculate how
* many nodes are between p1 and p2. If there are k nodes in between (excluding nodes pointed
to by p1 and p2), then the
* result is k (k could be 0). Replace the data fields of all nodes between p1 and p2 by k.
* Example: The original list is \"HEAD->1->7->5->0->3->NULL\". p1 points to node 1 (the
node with value 1), p2 points to
* node 0. There are two nodes in between p1 and p2. These two nodes\' data fields need to be
replaced by k=2. The
* resulting list should be \"HEAD->1->2->2->0->3->NULL\".
*
* You should modify sections labelled as \"fill in here\". Please leave the other sections (e.g., the
main
* function and all function protocols) intact.
*/
#include
using namespace std;
struct Node {
int data;
Node* link;
};
void disp(Node* head) {
// fill in here
}
Node* add(Node* head, int data) {
// fill in here
}
void magic(Node* p1, Node* p2) {
// fill in here
}
main() {
Node* head = NULL;
Node *p4, *p7;
for(int i = 0; i < 10; i++) {
head = add(head, i);
if (i==4) p4 = head;
if (i==7) p7 = head;
}
// at this point, we have created the following list: HEAD->9->8->7->6->5->4->3->2->1->0-
>NULL
// p4 now points to node 4 (the node containing 4); p7 now points to node 7 (the node
containing 7)
magic(p4, p7);
disp(head);
// between p4 and p7, there are k=2 nodes, and these two nodes\' values will be replaced by
k=2
// the output should be: HEAD->9->8->7->2->2->4->3->2->1->0->NULL
// housekeeping (free all nodes)
Node* tmp;
while (head) {
tmp = head;
head = head->link;
delete tmp;
}
}
Comments
Expert Answer
c++ Computational Complexity
/* Your task is to fill in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
shou.
C Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
#include iostream #includestdlib.h using namespace std;str.pdf
#include
#include
using namespace std;
struct node { //Task 1
char val;
node *next;
};
void printList(node *head) { //Task 2
if (head == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head;
int count = 0;
while(temp != NULL) {
cout << \"Node \" << count << \": \" << temp ->val << endl;
count++;
temp = temp->next;
}
}
struct node *globalhead = NULL;
void deepCopy(node *head1, node *head2) { //Task 3
if (head1 == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head1;
node *curr = NULL;
node *prev = NULL;
while(temp != NULL) {
curr = (struct node *)malloc(sizeof(struct node));
curr->val = temp->val;
if(prev==NULL){
head2 = curr;
globalhead = curr;
}else{
prev->next = curr;
}
prev = curr;
temp = temp->next;
}
}
int main() { //Task 4
// Example #1
node p00, p01, p02, p03, p10, p11, p12, p13;
// List 1: A B B B
p00.val = \'A\'; p00.next = &p01;
p01.val = \'B\'; p01.next = &p02;
p02.val = \'B\'; p02.next = &p03;
p03.val = \'B\'; p03.next = NULL;
p10.next = NULL;
cout<<\"First List:\"<
Solution
//Tested on Windos OS Dev c++
/*********************LinkedList.cpp********************/
#include
#include
using namespace std;
struct node { //Task 1
char val;
node *next;
};
void printList(node *head) { //Task 2
if (head == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head;
int count = 0;
while(temp != NULL) {
cout << \"Node \" << count << \": \" << temp ->val << endl;
count++;
temp = temp->next;
}
}
struct node *globalhead = NULL;
void deepCopy(node *head1, node **head2) { //Task 3
if (head1 == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head1;
node *curr = NULL;
node *prev = NULL;
while(temp != NULL) {
curr = (struct node *)malloc(sizeof(struct node));
curr->val = temp->val;
curr->next = NULL;
if(*head2==NULL){
*head2=curr;
}else{
prev=*head2;
while(prev->next!=NULL){
prev=prev->next;
}
prev->next=curr;
}
temp = temp->next;
}
}
int main() { //Task 4
// Example #1
node p00, p01, p02, p03, p10, p11, p12, p13;
// List 1: A B B B
p00.val = \'A\'; p00.next = &p01;
p01.val = \'B\'; p01.next = &p02;
p02.val = \'B\'; p02.next = &p03;
p03.val = \'B\'; p03.next = NULL;
p10.next = NULL;
cout<<\"First List:\"<.
1#include stdio.h#include stdlib.h#include assert.h .pdf
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
2
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
Solution
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node*.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
Recommended
using the single linked list code written in the class or in the lab,.pdf
using the single linked list code written in the class or in the lab, write and test the follow
function: Merge() function that takes two lists, each of which is sorted in increasing order, and
merges the two together into one list which is in increasing order.
Solution
//The main class
class MergeList {
Node head; // head of list
static Node a, b;
//Node class
static class Node {
int element;
Node next;
// Constructor to create a new node
Node(int d) {
element = d;
next = null;
}
}
void printlist(Node node) {
while (node != null) {
System.out.print(node.element + \" \");
node = node.next;
}
}
Node sortMerge(Node node1, Node node2) {
// Here we will check whether both the list are null or not.
if (node1 == null && node2 == null) {
return null;
}
// sortResultant node
Node sortRes = null;
// Now we will compare and merge the elements of both the list.
while (node1 != null && node2 != null) {
// We will compare current element of both lists
if (node1.element >= node2.element) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
} else {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
}
// If second list reached end, but first list has
// nodes. Add remaining nodes of first list at the
// front of sortResult list
while (node1 != null) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
}
// If first list reached end, but second list has
// node. Add remaining nodes of first list at the
// front of sortResult list
while (node2 != null) {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
return sortRes;
}
public static void main(String[] args) {
MergeList list = new MergeList();
Node sortResult = null;
//Create two linked list
list.a = new Node(5);
list.a.next = new Node(10);
list.a.next.next = new Node(15);
list.b = new Node(2);
list.b.next = new Node(3);
list.b.next.next = new Node(20);
System.out.println(\"List a before merge :\");
list.printlist(a);
System.out.println(\"\");
System.out.println(\"List b before merge :\");
list.printlist(b);
// Cal the function to merge the list in increasing order.
sortResult = list.sortedmerge(a, b);
System.out.println(\"\");
System.out.println(\"Merged linked list : \");
list.printlist(sortResult);
}
}.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
c++ Computational Complexity filling in the following three .pdf
c++ Computational Complexity
/* filling in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
should output
* \"HEAD->1->2->3->NULL\"
*
* 2) Node* add(Node* head, int data)
* Given the old head pointer to a list, create a new node using the value of data, and add the new
node to the front of
* the list. Return the new head pointer.
* Example: If the original list is \"HEAD->1->2->NULL\", then after adding 5, it should
become \"HEAD->5->1->2->NULL\". The
* return value should be the address of node 5.
*
* 3) void magic(Node* p1, Node* p2)
* p1 and p2 each points to a node from a same list. p1 may point to a later node than p2. Your
task is to calculate how
* many nodes are between p1 and p2. If there are k nodes in between (excluding nodes pointed
to by p1 and p2), then the
* result is k (k could be 0). Replace the data fields of all nodes between p1 and p2 by k.
* Example: The original list is \"HEAD->1->7->5->0->3->NULL\". p1 points to node 1 (the
node with value 1), p2 points to
* node 0. There are two nodes in between p1 and p2. These two nodes\' data fields need to be
replaced by k=2. The
* resulting list should be \"HEAD->1->2->2->0->3->NULL\".
*
* You should modify sections labelled as \"fill in here\". Please leave the other sections (e.g., the
main
* function and all function protocols) intact.
*/
#include
using namespace std;
struct Node {
int data;
Node* link;
};
void disp(Node* head) {
// fill in here
}
Node* add(Node* head, int data) {
// fill in here
}
void magic(Node* p1, Node* p2) {
// fill in here
}
main() {
Node* head = NULL;
Node *p4, *p7;
for(int i = 0; i < 10; i++) {
head = add(head, i);
if (i==4) p4 = head;
if (i==7) p7 = head;
}
// at this point, we have created the following list: HEAD->9->8->7->6->5->4->3->2->1->0-
>NULL
// p4 now points to node 4 (the node containing 4); p7 now points to node 7 (the node
containing 7)
magic(p4, p7);
disp(head);
// between p4 and p7, there are k=2 nodes, and these two nodes\' values will be replaced by
k=2
// the output should be: HEAD->9->8->7->2->2->4->3->2->1->0->NULL
// housekeeping (free all nodes)
Node* tmp;
while (head) {
tmp = head;
head = head->link;
delete tmp;
}
}
Comments
Expert Answer
c++ Computational Complexity
/* Your task is to fill in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
shou.
C Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
#include iostream #includestdlib.h using namespace std;str.pdf
#include
#include
using namespace std;
struct node { //Task 1
char val;
node *next;
};
void printList(node *head) { //Task 2
if (head == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head;
int count = 0;
while(temp != NULL) {
cout << \"Node \" << count << \": \" << temp ->val << endl;
count++;
temp = temp->next;
}
}
struct node *globalhead = NULL;
void deepCopy(node *head1, node *head2) { //Task 3
if (head1 == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head1;
node *curr = NULL;
node *prev = NULL;
while(temp != NULL) {
curr = (struct node *)malloc(sizeof(struct node));
curr->val = temp->val;
if(prev==NULL){
head2 = curr;
globalhead = curr;
}else{
prev->next = curr;
}
prev = curr;
temp = temp->next;
}
}
int main() { //Task 4
// Example #1
node p00, p01, p02, p03, p10, p11, p12, p13;
// List 1: A B B B
p00.val = \'A\'; p00.next = &p01;
p01.val = \'B\'; p01.next = &p02;
p02.val = \'B\'; p02.next = &p03;
p03.val = \'B\'; p03.next = NULL;
p10.next = NULL;
cout<<\"First List:\"<
Solution
//Tested on Windos OS Dev c++
/*********************LinkedList.cpp********************/
#include
#include
using namespace std;
struct node { //Task 1
char val;
node *next;
};
void printList(node *head) { //Task 2
if (head == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head;
int count = 0;
while(temp != NULL) {
cout << \"Node \" << count << \": \" << temp ->val << endl;
count++;
temp = temp->next;
}
}
struct node *globalhead = NULL;
void deepCopy(node *head1, node **head2) { //Task 3
if (head1 == NULL) {
cout << \"Empty list\" << endl;
return;
}
node *temp = head1;
node *curr = NULL;
node *prev = NULL;
while(temp != NULL) {
curr = (struct node *)malloc(sizeof(struct node));
curr->val = temp->val;
curr->next = NULL;
if(*head2==NULL){
*head2=curr;
}else{
prev=*head2;
while(prev->next!=NULL){
prev=prev->next;
}
prev->next=curr;
}
temp = temp->next;
}
}
int main() { //Task 4
// Example #1
node p00, p01, p02, p03, p10, p11, p12, p13;
// List 1: A B B B
p00.val = \'A\'; p00.next = &p01;
p01.val = \'B\'; p01.next = &p02;
p02.val = \'B\'; p02.next = &p03;
p03.val = \'B\'; p03.next = NULL;
p10.next = NULL;
cout<<\"First List:\"<.
1#include stdio.h#include stdlib.h#include assert.h .pdf
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
2
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
Solution
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node*.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
C Exam Help
I am Gabriel C. I am a C Exam Expert at programmingexamhelp.com. I hold a PhD. in Business analyst of Information Technology, Montreal College of Information Technology, Canada. I have been helping students with their exams for the past 8 years. You can hire me to take your exam in C.
Visit programmingexamhelp.com or email support@programmingexamhelp.com. You can also call on +1 678 648 4277 for any assistance with the C Exam.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
coding in C- Create a function called reverseList that takes the head.docx
coding in C;
Create a function called reverseList that takes the head of a linked list, reverses the order of all the nodes. For example, if the list contained 1, 2, 3, 4 in its nodes, the list will now contain 4, 3, 2, 1.
please add a main test.
Solution
Please find the required program below:
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
void push(struct node** head, int new_element)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_element;
new_node->next = (*head);
(*head) = new_node;
}
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
void reverseList(struct node** head)
{
struct node* prev = NULL;
struct node* current = *head;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head = prev;
}
int main()
{
struct node* head = NULL;
push(&head, 12);
push(&head, 14);
push(&head, 5);
push(&head, 8);
printf(\"\ Linked list Before Reversing :\ \");
printList(head);
reverseList(&head);
printf(\"\ Linked list After Reversing :\ \");
printList(head);
}
--------------------------------------------------------------------------------
OUTPUT:
Linked list Before Reversing :
8Â Â 5Â Â 14Â Â 12
Linked list After Reversing :
12Â Â 14Â Â 5Â Â 8
.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag ADT with two sentinels -one at the head and one at the tail. Strict DLink { TYPE value; strict DLink * next; struct DLink * prev;}; strict linked List { int size; struct DLink *frontSentinel; struct DLink *backSentinel;}; Write a function that at first reverses the list and then prints the values of the links in the list from front to back. Don\'t redirect to any other function. You must use assertions if necessary.
Solution
/* Program to reverse a doubly linked list */
#include <stdio.h>
#include <stdlib.h>
/* a node of the doubly linked list */
struct node
{
int data;
struct node *n;
struct node *pr;
};
/* Function to reverse a Doubly Linked List */
void reverse(struct node **head_r)
{
struct node *t = NULL;
struct node *cur = *head_r;
/* swap next and prev for all nodes of
doubly linked list */
while (cur != NULL)
{
t = cur->pr;
cur->pr = cur->n;
cur->n = t;
cur = cur->pr;
}
/* Before changing head, check for the cases like empty
list and list with only one node */
if(t != NULL )
*head_r = t->pr;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the Doubly Linked List */
void push(struct node** head_r, int new_data)
{
/* allocate node */
struct node* n_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
n_node->data = n_data;
/* since we are adding at the begining,
prev is always NULL */
n_node->pr = NULL;
/* link the old list off the new node */
n_node->n = (*head_r);
/* change prev of head node to new node */
if((*head_r) != NULL)
(*head_r)->pr = n_node ;
/* move the head to point to the new node */
(*head_r) = n_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Let us create a sorted linked list to test the functions
Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
printf(\"\ Original Linked list \");
printList(head);
/* Reverse doubly linked list */
reverse(&head);
printf(\"\ Reversed Linked list \");
printList(head);
getchar();
}
.
Write java program using linked list to get integer from user and.docx
Write java program using linked list to get integer from user and
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve included code to create an
Iterator. An Iterator is an object that iterates over another object – in this case, a circular linked
list. You can use the .next() method to advance the Iterator to the next item (the first time you
call it, the iterator will travel to node at index 0). Using iterator’s .remove() removes the node the
iterator is currently at. Say that we had a CircularLinkedList that looked like this: A ==> B ==>
C ==> D ==> E ==> Calling .next() three times will advance the iterator to index 2. Calling
.remove() once will remove the node at index 2. A ==> B ==> D ==> E ==> Calling .remove()
once more will remove the node now at index 2. A ==> B ==> E ==> The Iterator methods
handle wrapping around the CircularLinkedList. Be sure to create the iterator using l.iterator()
and after you’ve added all the nodes to the list, where l is your CircularLinkedList
Solution
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
head=null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element\'s next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode=new Node(e);
if(size==0){
head=newNode;
}
else{
Node last=getNode(size-1);
last.next=newNode;
}
newNode.next=head; //last element node is set to head
size++;
return true;
}
// need to handle
// out of bounds
// empty list
// adding to front
// adding to middle
// adding to \"end\"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e){
if(index>size) return false;
Node tmp=new Node(e);
if(index==0){
tmp.next=head;
Node last=getNode(size-1);
head=tmp;
last.next=head;
}
else {
Node curr=getNode(index-1);
tmp.next=curr.next;
curr.next=tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index ) {
Node prev=head;
for(int i=0;isize) {
e=null;
}
else if(index==0){
e = head.getElement();
Node last=getNode(size-1);
head=head.next;
last.next=head;
size--;
}
else{
Node prev=getNode(index-1);
Node curr=getNode(index);
e=curr.getElement();
prev.next=curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return \"\";
}
if(size == 1) {
return head.getElement().toString();
}
else{
do{
result.append(current.getElement());
result.append(\" ==> \");
current = current.next;
} while(current != head);
}
return result.toString();
}
public Iterator iterator() {
return new ListIterator();
}
/.
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
C++ please put everthing after you answer it- thanks Complete the stub.docx
C++ please put everthing after you answer it, thanks
Complete the stub file for the DoublyLinkedList implementation.
Please note: Any changes to the NodeType struct, not using the NodeType struct, or changing from template Type to using a specific data type will all be cause for deductions.
You are required to implement the methods:
insertFirst
insertLast
insertNode - (insert an item at a given index)
deleteNode - (remove a specific item)
The stub file contains the basic class format to implement the virtual methods from ListType. You should only need to complete the code for these four functions. Your code must maintain (or add) the node connections both forward and backward. In the double link list class these are called next and prev.
Your code must also maintain the count variable.
\} template Type ListType : : back ( ) const \{ assert(tail != NULL); //confirm tail exists return tail->data; //return the data of the tail node \} template void ListType >: :copyList (const ListType > \& otherList) \{ NodeType *newNode; //pointer to create a node NodeType current; //pointer to traverse the list if (head ! = NULL) //if the list is nonempty, make it empty destroyList(); if (otherList. head == NULL) //otherList is empty \{ head = NULL; tail = NULL; count = 0 ; \} else \{ current = otherList. head; // current points to the count = otherList . count; // list to be copied //copy the head node head = new NodeType < Type > ; / / create the node head->data = current > data; // copy the data head->next = NULL; // set the link field of tail = head; // the node to NULL // the next node //copy the remaining list while (current != NULL) \{ newNode = new NodeType < Type > ; // create a node newNode > data = current > data; // copy the data newNode->next = NULL; // set the link of // newNode to NULL tail->next = newNode; //attach newNode after tail tail = newNode; // make tail point to //the actual tail node current = current > next; 1/ make current point //to the next node \}/ /end while \}/lend else \}//end copylist
.
Linked List Copy Constructor Help!! Im having trouble doing this how w.docx
Linked List Copy Constructor Help!! Im having trouble doing this how would you do it since mine doesnt want to work.
LinkedList::LinkedList(const LinkedList & alinked_list)
{
head = NULL;
Node* newNode;
Node* nodePtr;
Node* tempPtr;
if (!alinked_list.head)
return;
nodePtr = alinked_list.head;
head = new Node;
head->getData = nodePtr->getData;
head->getLink = NULL;
nodePtr = nodePtr->getLink;
tempPtr = head;
while (nodePtr != NULL)
{
newNode = new Node;
newNode->getData = nodePtr->getData;
newNode->getLink = NULL;
tempPtr->getLink = newNode;
tempPtr = newNode;
nodePtr = nodePtr->getLink;
}
I have 2 classes.
class LinkedList: public Node
{
private:
Node* head; }
class Node {
int data;
Node* link; }
if you want me to provide all of the code i have i can gladly do that.
Solution
//Corrected Program
LinkedList::LinkedList(const LinkedList & alinked_list)
{
head = NULL;
Node* newNode;
Node* nodePtr;
Node* tempPtr;
if (alinked_list.head==NULL)
return;
nodePtr = alinked_list.head;
head = new Node;
head->setData(nodePtr->getData());
head->setLink(NULL);
nodePtr = nodePtr->getLink();
tempPtr = head;
while (nodePtr != NULL)
{
newNode = new Node;
newNode->setData(nodePtr->getData());
newNode->setLink(NULL);
tempPtr->setLink(newNode);
tempPtr = newNode;
nodePtr = nodePtr->getLink();
}
class LinkedList: public Node
{
private:
Node* head;
public:
LinkedList(const LinkedList & alinked_list);
} ;
class Node {
int data;
Node* link;
public:
setData(int d)
{
data=d;
}
setLink(Node * p)
{
link=p;
}
getLink()
{
retrun link;
}
getData()
{
return data;
}
}
;
.
Write a program in C that does the followinga) Builds a simple li.pdf
Write a program in C that does the following:
a) Builds a simple linked list consisting of 10 nodes each of which contains a random integer
between 50 and 100 inclusive. The list is to be built in main() and must be a local variable in
main().
b) Includes a user-defined function named printout(arg) that takes in the head pointer of the
already-built linked list as an argument and prints out the contents of the linked list to the screen,
starting from the head of the list to the tail. See the output below.
Node #0 contains 53
Node #1 contains 78
Node #2 contains 95
. . .
Node #20 contains 100
c) Includes a user-defined function called sum() that adds up the contents of the data members of
each node in the list, and prints out the total as follows:
The sum total of all nodes in this list is
d) Includes a user-defined function called reverse() that takes in the head pointer of the already-
built linked list as an argument and will physically reverse the order of the nodes in the list (i.e.,
the new head will be the old tail and the new tail will be the old head of the list). Use the
function printout() to output its contents now in reverse order. This does NOT mean that it will
be read backwards, but rather, the reversed list will be read from head to tail!
** PLEASE MAKE SURE THIS PROGRAM WORKS IN C LANGUAGE !!
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
int i=0;
while(temp != NULL)
{
printf(\"Node #%d contains %d\ \",i, temp->data);
temp = temp->next;
i++;
}
}
void sum(struct node *head)
{
int sum=0;
struct node *temp = head;
while(temp != NULL)
{
//printf(\"%d \", temp->data);
sum+=temp->data;
temp = temp->next;
}
printf(\"\ The sum total of all nodes in this list is %d\ \",sum);
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
int i,t;
for(i=0;i<10;i++)
{
// (rand() % 51) generates random number between 0 and 50 adding 50 generates random
number beween 50 and 100 both inclusive
t=(rand() % 51)+50;
push(&head, t);
}
printf(\"Given linked list\ \");
printList(head);
sum(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
return 0;
}.
After your review of the United States Constitution, and in consider.pdf
After your review of the United States Constitution, and in consideration of the controversy
amongst Republican party Presidential nominees regarding the citizenship status of Senator Ted
Cruz of Texas, is he indeed eligible to run for President of the United States? Be specific with
your answer; use the Constitution itself as the basis for your opinion.
Solution
Senator Ted Cruz has maintained that there are no constitutional barriers that prevent him from
running. And the challenges to his candidacy so far are few and far between. Though he was
born in Calgary, Canada he grew up in Texas, and graduated from there, later attending
Princeton University and Harvard Business School. Considered a prospective presidential
candidate, Cruz released his birth certificate which shows his mother was born in Delaware and
his father was born in Cuba. Most legal scholars maintain that Cruz is in the clear despite his
Canadian birthplace.
Two obvious provisions in the Constitution states that the candidate must be 35 years of age and
a resident of the United States for 14 years. The third provision maintains that he or she must be
a “natural born citizen.’ Legal experts opine that a natural citizen is someone who is a citizen
from birth and doesn’t have to go through a naturalization process to become a citizen. Which
means, then Cruz is a natural citizen by being born to an American mother and having her
citizenship at birth.
Two former solicitor generals, Neal Katyal and Paul Clement wrote that British common law
recognized children born outside of the British empire remained subjects, and were described by
law as “natural born.” The Naturalization Act of 1790 also states that children born abroad to
U.S. citizens were, too, natural born citizens. Though born in a foreign land, yet he has the right
to entitle himself to high honours in his adopted country. Exclusion of him from the office would
be unjust to his merits, and painful to his sensibilities.
*****.
Which region is used by default when a Component is added to a Borde.pdf
Which region is used by default when a Component is added to a BorderLayout?
A) NORTH
B) CENTER
C) WEST
D) LEFT
52.
The class GridLayout constructs ___________ to hold components.
A) a horizontal grid with one row
B) a vertical grid with one column
C) a grid with multiple rows and columns
D) a square grid with the same number of rows as columns
53.
When components are added to a container with a GridLayout, the component:
A) fills the next spot in the row, continuing in the first position of the next row if the current row
is full.
B) fills the next spot in the column, continuing in the first position of the next column if the
column is full.
C) fills in row x, column y if x and y are two integers passed to the Container method add.
D) fills in a random empty position in the grid.
54.
The fact that class Graphics is abstract contributes to Java’s portability because:
A) drawing is performed differently on every platform that supports Java. A subclass of Graphics
must be created that uses the drawing capabilities of the current platform.
B) objects of non-abstract classes can only be instantiated on the Windows platform.
C) drawing should not be performed on non-Linux platforms.
D) Class Graphics is not abstract.
55.
Which of the following statements about the Graphics object is true?
A. The Graphics object is an argument to class Component’s repaint method.
B. The Graphics object is instantiated by the user.
C. The Graphics object is the argument to a lightweight GUI component\'s paintComponent
method.
D. The Graphics class is abstract.
E. The Graphics object manages a graphics context.
A) A, C, E.
B) C, D, E.
C) A, B, D, E.
D) All are true.
56.
Which of the following are valid Java statements?
A. Color c = new Color( 0, 255, 0 );
B. Color c = new Color( 0.0f, 1.0f, 0.0f );
C. Color c = new Color( 0.0d, 1.0d, 0.0d );
D. setGreen( c.getGreen() - 2 );
A) All of the above.
B) A, B, C.
C) A, B, D.
D) A, B.
57.
The JColorChooser dialog allows colors to be chosen by all but which of the following?
A) Swatches
B) Hue, saturation, brightness
C) Gradient, cycle, brightness
D) Red, Green, Blue
58.
Method getFont of class Graphics returns:
A) the current font name as a string.
B) the font size in points.
C) a Graphics object representing the current font.
D) a Font object representing the current font.
59.
The Java statement: g.fillOval( 290, 100, 90, 55 );
A) Draws a filled oval with its center at coordinates x=290, y=100, with height=90 and
width=55.
B) Draws a filled oval with its left most point at coordinates x=290, y=100, with height=90 and
width=55.
C) Draws a filled oval bounded by a rectangle with its upper left corner at coordinates x=290,
y=100, with width=90 and height=55.
D) Draws a filled oval bounded by a rectangle with its upper left corner at coordinates x=290,
y=100, with height=90 and width=55.
60.
Which of the following statements draws an arc that sweeps from the top of an oval to the left-
most edge?
A) g.drawArc( 200, 100, 100, 50.
More Related Content
Similar to Write a function that combines two lists by zipping two lists togeth.pdf
C Exam Help
I am Gabriel C. I am a C Exam Expert at programmingexamhelp.com. I hold a PhD. in Business analyst of Information Technology, Montreal College of Information Technology, Canada. I have been helping students with their exams for the past 8 years. You can hire me to take your exam in C.
Visit programmingexamhelp.com or email support@programmingexamhelp.com. You can also call on +1 678 648 4277 for any assistance with the C Exam.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
coding in C- Create a function called reverseList that takes the head.docx
coding in C;
Create a function called reverseList that takes the head of a linked list, reverses the order of all the nodes. For example, if the list contained 1, 2, 3, 4 in its nodes, the list will now contain 4, 3, 2, 1.
please add a main test.
Solution
Please find the required program below:
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
void push(struct node** head, int new_element)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_element;
new_node->next = (*head);
(*head) = new_node;
}
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
void reverseList(struct node** head)
{
struct node* prev = NULL;
struct node* current = *head;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head = prev;
}
int main()
{
struct node* head = NULL;
push(&head, 12);
push(&head, 14);
push(&head, 5);
push(&head, 8);
printf(\"\ Linked list Before Reversing :\ \");
printList(head);
reverseList(&head);
printf(\"\ Linked list After Reversing :\ \");
printList(head);
}
--------------------------------------------------------------------------------
OUTPUT:
Linked list Before Reversing :
8Â Â 5Â Â 14Â Â 12
Linked list After Reversing :
12Â Â 14Â Â 5Â Â 8
.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag ADT with two sentinels -one at the head and one at the tail. Strict DLink { TYPE value; strict DLink * next; struct DLink * prev;}; strict linked List { int size; struct DLink *frontSentinel; struct DLink *backSentinel;}; Write a function that at first reverses the list and then prints the values of the links in the list from front to back. Don\'t redirect to any other function. You must use assertions if necessary.
Solution
/* Program to reverse a doubly linked list */
#include <stdio.h>
#include <stdlib.h>
/* a node of the doubly linked list */
struct node
{
int data;
struct node *n;
struct node *pr;
};
/* Function to reverse a Doubly Linked List */
void reverse(struct node **head_r)
{
struct node *t = NULL;
struct node *cur = *head_r;
/* swap next and prev for all nodes of
doubly linked list */
while (cur != NULL)
{
t = cur->pr;
cur->pr = cur->n;
cur->n = t;
cur = cur->pr;
}
/* Before changing head, check for the cases like empty
list and list with only one node */
if(t != NULL )
*head_r = t->pr;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the Doubly Linked List */
void push(struct node** head_r, int new_data)
{
/* allocate node */
struct node* n_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
n_node->data = n_data;
/* since we are adding at the begining,
prev is always NULL */
n_node->pr = NULL;
/* link the old list off the new node */
n_node->n = (*head_r);
/* change prev of head node to new node */
if((*head_r) != NULL)
(*head_r)->pr = n_node ;
/* move the head to point to the new node */
(*head_r) = n_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Let us create a sorted linked list to test the functions
Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
printf(\"\ Original Linked list \");
printList(head);
/* Reverse doubly linked list */
reverse(&head);
printf(\"\ Reversed Linked list \");
printList(head);
getchar();
}
.
Write java program using linked list to get integer from user and.docx
Write java program using linked list to get integer from user and
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve included code to create an
Iterator. An Iterator is an object that iterates over another object – in this case, a circular linked
list. You can use the .next() method to advance the Iterator to the next item (the first time you
call it, the iterator will travel to node at index 0). Using iterator’s .remove() removes the node the
iterator is currently at. Say that we had a CircularLinkedList that looked like this: A ==> B ==>
C ==> D ==> E ==> Calling .next() three times will advance the iterator to index 2. Calling
.remove() once will remove the node at index 2. A ==> B ==> D ==> E ==> Calling .remove()
once more will remove the node now at index 2. A ==> B ==> E ==> The Iterator methods
handle wrapping around the CircularLinkedList. Be sure to create the iterator using l.iterator()
and after you’ve added all the nodes to the list, where l is your CircularLinkedList
Solution
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
head=null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element\'s next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode=new Node(e);
if(size==0){
head=newNode;
}
else{
Node last=getNode(size-1);
last.next=newNode;
}
newNode.next=head; //last element node is set to head
size++;
return true;
}
// need to handle
// out of bounds
// empty list
// adding to front
// adding to middle
// adding to \"end\"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e){
if(index>size) return false;
Node tmp=new Node(e);
if(index==0){
tmp.next=head;
Node last=getNode(size-1);
head=tmp;
last.next=head;
}
else {
Node curr=getNode(index-1);
tmp.next=curr.next;
curr.next=tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index ) {
Node prev=head;
for(int i=0;isize) {
e=null;
}
else if(index==0){
e = head.getElement();
Node last=getNode(size-1);
head=head.next;
last.next=head;
size--;
}
else{
Node prev=getNode(index-1);
Node curr=getNode(index);
e=curr.getElement();
prev.next=curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return \"\";
}
if(size == 1) {
return head.getElement().toString();
}
else{
do{
result.append(current.getElement());
result.append(\" ==> \");
current = current.next;
} while(current != head);
}
return result.toString();
}
public Iterator iterator() {
return new ListIterator();
}
/.
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
C++ please put everthing after you answer it- thanks Complete the stub.docx
C++ please put everthing after you answer it, thanks
Complete the stub file for the DoublyLinkedList implementation.
Please note: Any changes to the NodeType struct, not using the NodeType struct, or changing from template Type to using a specific data type will all be cause for deductions.
You are required to implement the methods:
insertFirst
insertLast
insertNode - (insert an item at a given index)
deleteNode - (remove a specific item)
The stub file contains the basic class format to implement the virtual methods from ListType. You should only need to complete the code for these four functions. Your code must maintain (or add) the node connections both forward and backward. In the double link list class these are called next and prev.
Your code must also maintain the count variable.
\} template Type ListType : : back ( ) const \{ assert(tail != NULL); //confirm tail exists return tail->data; //return the data of the tail node \} template void ListType >: :copyList (const ListType > \& otherList) \{ NodeType *newNode; //pointer to create a node NodeType current; //pointer to traverse the list if (head ! = NULL) //if the list is nonempty, make it empty destroyList(); if (otherList. head == NULL) //otherList is empty \{ head = NULL; tail = NULL; count = 0 ; \} else \{ current = otherList. head; // current points to the count = otherList . count; // list to be copied //copy the head node head = new NodeType < Type > ; / / create the node head->data = current > data; // copy the data head->next = NULL; // set the link field of tail = head; // the node to NULL // the next node //copy the remaining list while (current != NULL) \{ newNode = new NodeType < Type > ; // create a node newNode > data = current > data; // copy the data newNode->next = NULL; // set the link of // newNode to NULL tail->next = newNode; //attach newNode after tail tail = newNode; // make tail point to //the actual tail node current = current > next; 1/ make current point //to the next node \}/ /end while \}/lend else \}//end copylist
.
Linked List Copy Constructor Help!! Im having trouble doing this how w.docx
Linked List Copy Constructor Help!! Im having trouble doing this how would you do it since mine doesnt want to work.
LinkedList::LinkedList(const LinkedList & alinked_list)
{
head = NULL;
Node* newNode;
Node* nodePtr;
Node* tempPtr;
if (!alinked_list.head)
return;
nodePtr = alinked_list.head;
head = new Node;
head->getData = nodePtr->getData;
head->getLink = NULL;
nodePtr = nodePtr->getLink;
tempPtr = head;
while (nodePtr != NULL)
{
newNode = new Node;
newNode->getData = nodePtr->getData;
newNode->getLink = NULL;
tempPtr->getLink = newNode;
tempPtr = newNode;
nodePtr = nodePtr->getLink;
}
I have 2 classes.
class LinkedList: public Node
{
private:
Node* head; }
class Node {
int data;
Node* link; }
if you want me to provide all of the code i have i can gladly do that.
Solution
//Corrected Program
LinkedList::LinkedList(const LinkedList & alinked_list)
{
head = NULL;
Node* newNode;
Node* nodePtr;
Node* tempPtr;
if (alinked_list.head==NULL)
return;
nodePtr = alinked_list.head;
head = new Node;
head->setData(nodePtr->getData());
head->setLink(NULL);
nodePtr = nodePtr->getLink();
tempPtr = head;
while (nodePtr != NULL)
{
newNode = new Node;
newNode->setData(nodePtr->getData());
newNode->setLink(NULL);
tempPtr->setLink(newNode);
tempPtr = newNode;
nodePtr = nodePtr->getLink();
}
class LinkedList: public Node
{
private:
Node* head;
public:
LinkedList(const LinkedList & alinked_list);
} ;
class Node {
int data;
Node* link;
public:
setData(int d)
{
data=d;
}
setLink(Node * p)
{
link=p;
}
getLink()
{
retrun link;
}
getData()
{
return data;
}
}
;
.
Write a program in C that does the followinga) Builds a simple li.pdf
Write a program in C that does the following:
a) Builds a simple linked list consisting of 10 nodes each of which contains a random integer
between 50 and 100 inclusive. The list is to be built in main() and must be a local variable in
main().
b) Includes a user-defined function named printout(arg) that takes in the head pointer of the
already-built linked list as an argument and prints out the contents of the linked list to the screen,
starting from the head of the list to the tail. See the output below.
Node #0 contains 53
Node #1 contains 78
Node #2 contains 95
. . .
Node #20 contains 100
c) Includes a user-defined function called sum() that adds up the contents of the data members of
each node in the list, and prints out the total as follows:
The sum total of all nodes in this list is
d) Includes a user-defined function called reverse() that takes in the head pointer of the already-
built linked list as an argument and will physically reverse the order of the nodes in the list (i.e.,
the new head will be the old tail and the new tail will be the old head of the list). Use the
function printout() to output its contents now in reverse order. This does NOT mean that it will
be read backwards, but rather, the reversed list will be read from head to tail!
** PLEASE MAKE SURE THIS PROGRAM WORKS IN C LANGUAGE !!
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
int i=0;
while(temp != NULL)
{
printf(\"Node #%d contains %d\ \",i, temp->data);
temp = temp->next;
i++;
}
}
void sum(struct node *head)
{
int sum=0;
struct node *temp = head;
while(temp != NULL)
{
//printf(\"%d \", temp->data);
sum+=temp->data;
temp = temp->next;
}
printf(\"\ The sum total of all nodes in this list is %d\ \",sum);
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
int i,t;
for(i=0;i<10;i++)
{
// (rand() % 51) generates random number between 0 and 50 adding 50 generates random
number beween 50 and 100 both inclusive
t=(rand() % 51)+50;
push(&head, t);
}
printf(\"Given linked list\ \");
printList(head);
sum(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
return 0;
}.
Similar to Write a function that combines two lists by zipping two lists togeth.pdf (20)
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
coding in C- Create a function called reverseList that takes the head.docx
coding in C- Create a function called reverseList that takes the head.docx
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++I am really new to C++, so links are really .pdf
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag.docx
Write java program using linked list to get integer from user and.docx
Write java program using linked list to get integer from user and.docx
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a.pdf
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve inc.pdf
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header usin.pdf
C++ please put everthing after you answer it- thanks Complete the stub.docx
C++ please put everthing after you answer it- thanks Complete the stub.docx
Linked List Copy Constructor Help!! Im having trouble doing this how w.docx
Linked List Copy Constructor Help!! Im having trouble doing this how w.docx
Write a program in C that does the followinga) Builds a simple li.pdf
Write a program in C that does the followinga) Builds a simple li.pdf
More from banishkyliachomasl99
After your review of the United States Constitution, and in consider.pdf
After your review of the United States Constitution, and in consideration of the controversy
amongst Republican party Presidential nominees regarding the citizenship status of Senator Ted
Cruz of Texas, is he indeed eligible to run for President of the United States? Be specific with
your answer; use the Constitution itself as the basis for your opinion.
Solution
Senator Ted Cruz has maintained that there are no constitutional barriers that prevent him from
running. And the challenges to his candidacy so far are few and far between. Though he was
born in Calgary, Canada he grew up in Texas, and graduated from there, later attending
Princeton University and Harvard Business School. Considered a prospective presidential
candidate, Cruz released his birth certificate which shows his mother was born in Delaware and
his father was born in Cuba. Most legal scholars maintain that Cruz is in the clear despite his
Canadian birthplace.
Two obvious provisions in the Constitution states that the candidate must be 35 years of age and
a resident of the United States for 14 years. The third provision maintains that he or she must be
a “natural born citizen.’ Legal experts opine that a natural citizen is someone who is a citizen
from birth and doesn’t have to go through a naturalization process to become a citizen. Which
means, then Cruz is a natural citizen by being born to an American mother and having her
citizenship at birth.
Two former solicitor generals, Neal Katyal and Paul Clement wrote that British common law
recognized children born outside of the British empire remained subjects, and were described by
law as “natural born.” The Naturalization Act of 1790 also states that children born abroad to
U.S. citizens were, too, natural born citizens. Though born in a foreign land, yet he has the right
to entitle himself to high honours in his adopted country. Exclusion of him from the office would
be unjust to his merits, and painful to his sensibilities.
*****.
Which region is used by default when a Component is added to a Borde.pdf
Which region is used by default when a Component is added to a BorderLayout?
A) NORTH
B) CENTER
C) WEST
D) LEFT
52.
The class GridLayout constructs ___________ to hold components.
A) a horizontal grid with one row
B) a vertical grid with one column
C) a grid with multiple rows and columns
D) a square grid with the same number of rows as columns
53.
When components are added to a container with a GridLayout, the component:
A) fills the next spot in the row, continuing in the first position of the next row if the current row
is full.
B) fills the next spot in the column, continuing in the first position of the next column if the
column is full.
C) fills in row x, column y if x and y are two integers passed to the Container method add.
D) fills in a random empty position in the grid.
54.
The fact that class Graphics is abstract contributes to Java’s portability because:
A) drawing is performed differently on every platform that supports Java. A subclass of Graphics
must be created that uses the drawing capabilities of the current platform.
B) objects of non-abstract classes can only be instantiated on the Windows platform.
C) drawing should not be performed on non-Linux platforms.
D) Class Graphics is not abstract.
55.
Which of the following statements about the Graphics object is true?
A. The Graphics object is an argument to class Component’s repaint method.
B. The Graphics object is instantiated by the user.
C. The Graphics object is the argument to a lightweight GUI component\'s paintComponent
method.
D. The Graphics class is abstract.
E. The Graphics object manages a graphics context.
A) A, C, E.
B) C, D, E.
C) A, B, D, E.
D) All are true.
56.
Which of the following are valid Java statements?
A. Color c = new Color( 0, 255, 0 );
B. Color c = new Color( 0.0f, 1.0f, 0.0f );
C. Color c = new Color( 0.0d, 1.0d, 0.0d );
D. setGreen( c.getGreen() - 2 );
A) All of the above.
B) A, B, C.
C) A, B, D.
D) A, B.
57.
The JColorChooser dialog allows colors to be chosen by all but which of the following?
A) Swatches
B) Hue, saturation, brightness
C) Gradient, cycle, brightness
D) Red, Green, Blue
58.
Method getFont of class Graphics returns:
A) the current font name as a string.
B) the font size in points.
C) a Graphics object representing the current font.
D) a Font object representing the current font.
59.
The Java statement: g.fillOval( 290, 100, 90, 55 );
A) Draws a filled oval with its center at coordinates x=290, y=100, with height=90 and
width=55.
B) Draws a filled oval with its left most point at coordinates x=290, y=100, with height=90 and
width=55.
C) Draws a filled oval bounded by a rectangle with its upper left corner at coordinates x=290,
y=100, with width=90 and height=55.
D) Draws a filled oval bounded by a rectangle with its upper left corner at coordinates x=290,
y=100, with height=90 and width=55.
60.
Which of the following statements draws an arc that sweeps from the top of an oval to the left-
most edge?
A) g.drawArc( 200, 100, 100, 50.
What is the e- donor in the photosynthesis system And is this e- tr.pdf
What is the e- donor in the photosynthesis system? And is this e- transfer perfect and why?
Solution
photolysis of water (an electron donor) produces oxygen molecules SO HERE WATER IS
HYDROGEN DONOAR IN PHOTOSYNTHESIS
this is perfect reaction because in photolysis during photosynthesis two water molecules are
oxidized through four successive charge-separation reactions to yield a molecule of diatomic
oxygen and four hydrogen ions.
What is a sample Population Sampling frameSolutionA sample .pdf
What is a sample? Population? Sampling frame?
Solution
A sample is a set of items from a population used to study the statistical properties of the
population.
A population is the entire group of data the sample intends to generalize. It is the entire group of
data from which the sample is drawn.
The sampling frame is the list of items forming a population from which a sample is taken..
What are the steps of the PBE processSolutionPerdew–Burke–Ernz.pdf
What are the steps of the PBE process
Solution
Perdew–Burke–Ernzerhof or PBE is a function for exchange- correlation energy derivations. It
helps in finding of quantum mechanical modeling through Density functional theory (DFT). The
PBE takes for the function of integration process. The theory is very useful for techniques like
NMR..
Thomas Savery was an English inventor. He invented the first steam e.pdf
Thomas Savery was an English inventor. He invented the first steam engine. Why? What
significance would this have?
Solution
n 1698, British inventor Thomas Savery patented a steam-powered pump, which he described as
an \"engine to raise water by fire.\" Savery\'s very basic engine relied on steam to create a
vacuum and pull water upwards through a pipe — a theory that had been around for several
centuries but never successfully applied.
By that time, the speedy engine\'s reputation was gaining steam well beyond mining circles,
moving indoors to other areas of industry from metalworking to textiles, where it was adapted to
the rotating wheel system common in European mills.
A savvy businessman, Watt marketed his machine by calculating the number of horses his
engine would replace, coining the term \"horsepower\" in the process.
The simultaneous perfection of the steam engine and the beginning of the Industrial Revolution
is a chicken and egg scenario that historians have long debated. The world was becoming an
industrialized place before the advent of steam power, but would never have progressed so
quickly without it, they argue.
Factories that still relied on wind or water power to drive their machines during the Industrial
Revolution were confined to certain locales; steam meant that factories could be built anywhere,
not just along fast-flowing rivers.
Those factories benefited from one of the world\'s greatest partnerships — that of Watt and
Matthew Boulton, a British manufacturer. Together, they tailored Watt\'s steam engine to any
company that could use it, amassing great fortunes for themselves but also sharing research over
vast distances.
Transportation was one of those important beneficiaries. By the early 1800s, high-pressure steam
engines had become compact enough to move beyond the factory, prompting the first steam-
powered locomotive to hit the rails in Britain in 1804. For the first time in history, goods were
transported over land by something other than the muscle of man or a animal.
The strongest attractive forces between molecules of O_2 are ionic .pdf
The strongest attractive forces between molecules of O_2 are: ionic covalent hydrogen
bonding dipole-dipole attractions dispersion forces
Solution
The attractive forces between molecules of O2 will be dispersion forces. This is because O2 is a
non-polar molecule so there will be no dipole-dipole interactions, also there is no hydrogen atom
so no question of Hydrogen bonding. Dispersion forces are exhibited by non-polar molecules
because of thecorrelated movements of the electrons in interacting molecules. The electrons in
adjacent molecules repel each other and so they run away from their usual place. As a result,
electron density in a molecule becomes redistributed in proximity to another molecule, which is
according to quantum mechanical theory of dispersion forces. This is frequently described as the
formation of instantaneous dipoles that attract each other. These type of Dispersion forces are
present between all chemical groups, and usually represent the main part of the total interaction
force in condensed matter..
The lymphatic capillaries begin at this site right atrial chamber .pdf
The lymphatic capillaries begin at this site: right atrial chamber lymph inguinal nodes Wood
capillary bed splenic vessels Lymphatic capillaries differ from vascular capillaries in being a
cu-de-sac True False
Solution
33. True
lymphatic capillaries are also called blind, as they are closed at tip.
32. Right atrial chamber:
the lymphatic system, unlike the blood capillaries , do not have a separate pump to carry the
liquids.Instead, they carry the extra fluids oozing out from areas of high pressure to areas of low
pressure. Lymphatic capillaries are present throughout the body, though they start from the right
atrial chamber..
The adjusted coefficient of determination is adjusted for theA. n.pdf
The adjusted coefficient of determination is adjusted for the:
A. number of regression parameters including the y-intercept.
B. number of dependent variables and the sample size.
C. number of independent variables and the sample size.
D. coefficient of correlation and the significance level.
Solution
The adjusted coefficient of determination is adjusted for the number of independent variables
(explanatory variables) and the sample size..
Surface proteinsWhat is the function of surface marker proteins li.pdf
Surface proteins
What is the function of surface marker proteins like the major histocompatibility complex?
1 Surface marker proteins are enzymes that break down food molecules that are then absorbed.
2 Surface marker proteins are receptors for hormones that then send messages out of the cell.
3 Surface marker proteins are ion channels that allow ions to enter the cell.
4 Surface marker proteins are identifiers that allow the immune system to recognize “self” cells.
5 Surface marker proteins are anchoring proteins that attach neighboring cells to each other.
Solution
4. Surface marker proteins are identifiers that allow the immune system to recognize .
Surface marker are the marker which are present on the surface of the cell they act like a receptor
where the binding of antigen antibody happen which will cause a immune response. The immune
system uses these proteins to tell friendly cells from foreign invaders. They are as unique as
fingerprints. They play an important role in organ transplants..
2. The CSUN IEEE chapter is to choose a president, treasurer and sec.pdf
2. The CSUN IEEE chapter is to choose a president, treasurer and secretary, all different, from a
group of 10 students. How many different choices of officers are possible if:
a. There are no restrictions
b. A and B will not serve together
c. C and D will serve together or not at all
d. E must be an officer
e. F will serve only if he is a president.
Solution
a.There are no restrictions- 10C3
e. F will serve only if he is a president.-10C1.
of the following choices with has the most water and organic materia.pdf
of the following choices with has the most water and organic material and the least crystalline
materials: enamel, dentin, bone, calcified cartilage, cartilage
Solution
The enamel is the structure which is found in the tooth which contains highest amount of water
and organic materials upto 96%...!!.
Listed below are blood types for several all possible children and th.pdf
Listed below are blood types for several all possible children and their mothers. Give genotypes
and blood types for the father of each child. Child\'s blood type Mothers blood type A A O B
AB A B AB
Solution
Child\' s blood type Mother\'s blood type father blood type A A IA IA or A O B IA IA or
A AB A IA IB or AB B AB I A I B or AB.
list in order of appearance the four stages of the origin of life an.pdf
list in order of appearance the four stages of the origin of life and explain what was necessary to
occur in order for life to have evolved in this fashion
Solution
Evolution occurred in four stages:
Stage 1: Initially, it is thought that various small inorganic molecules occurred in the primitive
Earth. Hydrogen, ammonia, methane and water vapor were the main components. These
molecules combined together to form small organic molecules, which included amino acids.
Please note that ultraviolet radiations of the sun aided this process. This phenomenon is known
as Abiogenesis. Abiogenesis was important for the beginning of evolution in successive stages.
If abiogenesis did not occur, complex molecules (which form from small organic molecules) will
never form.
Stage 2: In this stage, the simple organic molecules (amino acids) further accumulated to form
complex and large organic molecules like proteins (polymers). Water, oxygen, ozone and
enzymes evolved into the primitive Earth. This stage was important because, it resulted in the
formation of enzymes, the biological catalysts, without which life of present Earth is impossible.
Stage 3: Polymers interacted together to form aggregates. These were known as proto-bionts.
They had the capability of reproduction. So, abiogenic evolution shifted to biogenic evolution.
Now new organisms/life will generate from pre-existing life. This stage was important because
of the introduction of concept of evolution.
Stage 4: Protobionts generated the ability of reproduction. So, genetic material could be
transferred from one generation of other. This stage was important for variation and evolution.
RNA was originated, and its work into the living systems was well-established in this stage..
java programmingAn anonymous class methods cannot access instanc.pdf
java programming
An anonymous class\' methods cannot access instance variables belonging to the class in which it
is defined.
is this TRUE or FALSE?
Solution
True. An anonymous class\' methods cannot access instance variables belonging to the class in
which it is defined.
Because anonymous class similar like local class, cannot be public, private or static..
2 which of 1, which two types vnokeetons 6. What s microntuue mad.pdf
2 which of 1, which two types vnokeetons 6. What s microntuue made en whet af ener at s What
is micrallamart made ofr where s nevrorti? what the tune on ef tha Name 3 Pathology el
Altheimer\'s dseate what the cause what\'s the teretien of each type of 12. Whare the Hanction
blood barnet what s 14 which type of ela celbianolre aben ater onal oord nury? What\'s the 16
Mou need to know each phane of action potential dupolaritation, retractory lie. channel period,
he underlying such as whan mechanisms, 12 How is action patental propagat ion triggers
neurotranMtitter release? potential (loca 19 what are the differences between action potential and
dendritic 20 What\'s the function of presynaptic inhibition post synaptic inhibinion, auto
Solution
1). During gastrulation, the gastrula cells arrange themselves into three distinct germ layers
namely, the ectoderm, endoderm, and mesoderm.
Each of these primary germ layers has a distinct fate in which they develop into a physiological
system, tissue, or organ in a fully developed human. The endoderm and mesoderm are inner most
layers of the gastrula. The outermost layer, or ectodermdevelops into the nervous system,
portions of the eye and teeth, posterior pituitary gland, and adrenal medulla..
16) The least expensive form of Internet connection is usually O cabl.pdf
16) The least expensive form of Internet connection is usually O cable O DSL O FTTH O dial-
up Next Question
Solution
16.
least expensive and lowest form of internet connection is usually dial up
18.
Ans: Princeton
By December 5, 1969 the ARPANET consisted of four nodesOffsite Link:
1. University of California, Los Angeles (UCLA), where Leonard Kleinrock had established a
Network Measurement Center.
2. The Stanford Research Institute\'s Augmentation Research Center, where Douglas Engelbart
had created the ground-breaking NLS system, a very important early hypertext system.
3. University of California, Santa Barbara (UCSB), Culler-Fried Interactive Mathematics
Center.
4. The University of Utah\'s Computer Science Department, where Ivan Sutherland had moved.
19.
They decrease system performance
20.
Cyberstalking is the use of the Internet or other electronic means to stalk or harass an
individual, a group, or an organization.
i. What does Diaspora means 2 Diaspora peoples refer to who Name th.pdf
i. What does Diaspora means? 2 Diaspora peoples refer to who? Name the two places diaspora
peoples main their connection and identity State one reason Diaspora study has become much
more important today s State one characteristic of diaspora groups: What does African Diaspora
means? In studying African Diaspora History, one has to begin with what and why? State one
reason why it is complex and difficulty to study African Diaspora history Name two Muslim
societies outside Africa that have discrete African communities. e Name one service performed
by enslaved Africans who settled in India. 11. What were the known names for Africans and
descendants of Africans found in India? What region of Africa did Arab slave dealers take most
of the African slaves? 13. Name a Greek Mathematician who is believed to have studied in
Egypt. . What is the Hamitic Hypothesis? s Define Monogenesis and Polygenesis. Describe the
\"Out of Africa\" Theory 17. Name the two scientists whose works have closely associated with
the \"Out of Africa\" Theory Based on the video about the dawn of man, what year was the first
human-like skeletons
Solution
Q.1 In general meaning, Diaspora refers to the people living or dispersed at places outside of the
homeland or homenation. So if I say indian Diaspora, it refers to the people of Indian nationality
that have permanently moved from India to other parts of the world. If I say African Diaspora, it
refers the people from the Africa who have moved to other countries such as America due to
some historic movements, such as slavery.
Q.2 These are the people who were moved from their homeland for some reason and now are
dispersed or scattered in foreign lands, living there permanently. An African-American is a
person of African Diaspora, a Mexican-American is a person of Mexican diaspora and an Indian-
American is the person of Indian diaspora.
Q.3 For African people in America brought by slavery, maintaining their identity was not a
difficult task, because they were easily distinguished by the black skin color, but among other
diasporas such as Jews other factors contribute to the fact that they maintained their identity for
more than 3000 years.
Jews people maintained a reading culture, and they are taught about the purpose of their life. So
the main factor that has contributed in the religion. And on the day of the Sabath, they don\'t just
pray, but they meet at one place in groups and together they pray. So these religious gathering
places also contribute. Similarly for any other other religion, the places of religious worship
contribute in maintaing the identity of the people and creating connections..
How do these primary source images reflect how human societies opera.pdf
How do these primary source images reflect how human societies operated in the prehistoric
world?
Prehistoric Cave Paintings, various locations worldwide, 10,000 to 35,000 BCE
Woman of Willendorf, stone, 25-28,000 BCE, 4.4 inches
Solution
It is difficult to reconstruct the human society as it existed 35000 years ago from the painting that
they had painted over the surface of the caves. It seems that humans primarily hunted for their
food. The study of the paintings seems to suggest that the majority of the paintings were done by
young men though some of the hand prints in some of the caves seem to be those of women.
Women may also have painted. Writing was not a part of human culture when the paintings were
made and the meaning of the paintings remain elusive. Perhaps some rituals and traditions and
faith in an omnipotent creature were the reasons for the paintings.
The use of the caves is also not clear. The caves are found in remote regions and while the
paintings are found in the interior of the caves also, it is suggested that the occupation of the
caves was only in the mouth of the caves.
The paintings may have been used to impart survival lessons, hunting strategies or to portray
legends or to illustrate traditions and rituals.
The woman of Willendorf
Nothing is known about the portrayal of the female figure in the Woman of Willendorf. It is
quite clear that the features of the figure are exaggerated. The figure has no feet so perhaps it was
fixed to the ground and worshipped as a goddess. The features of the head and face are not
visible . It is also thought that the statue may be a representation of the fantasy of the young man
(men) who made the statue..
How does vesicle budding occurs in yeastDoes the vacuoles uses CopI.pdf
How does vesicle budding occurs in yeast?Does the vacuoles uses CopI or CopII formation or is
there a specific budding mechanism in yeast?
Please explain in details.
Solution
Sec proteins are responsible for vesicle budding. These proteins are present in vesicle named as
Cop II. This is a coat protein that makes up the vesicle.
Please note that Cop II vesicles bud off proteins from ER towards cis-Golgi, while Cop I vesicles
bud off proteins from cis-Golgi to trans-Golgi. The mechanism of budding is similar in yeast; in
fact yeast has been used as a model organism for studying vesicular transport and secretory
pathway of eukaryotes.
Vacuoles also Cop I and Cop II formation..
More from banishkyliachomasl99 (20)
After your review of the United States Constitution, and in consider.pdf
After your review of the United States Constitution, and in consider.pdf
Which region is used by default when a Component is added to a Borde.pdf
Which region is used by default when a Component is added to a Borde.pdf
What is the e- donor in the photosynthesis system And is this e- tr.pdf
What is the e- donor in the photosynthesis system And is this e- tr.pdf
What is a sample Population Sampling frameSolutionA sample .pdf
What is a sample Population Sampling frameSolutionA sample .pdf
What are the steps of the PBE processSolutionPerdew–Burke–Ernz.pdf
What are the steps of the PBE processSolutionPerdew–Burke–Ernz.pdf
Thomas Savery was an English inventor. He invented the first steam e.pdf
Thomas Savery was an English inventor. He invented the first steam e.pdf
The strongest attractive forces between molecules of O_2 are ionic .pdf
The strongest attractive forces between molecules of O_2 are ionic .pdf
The lymphatic capillaries begin at this site right atrial chamber .pdf
The lymphatic capillaries begin at this site right atrial chamber .pdf
The adjusted coefficient of determination is adjusted for theA. n.pdf
The adjusted coefficient of determination is adjusted for theA. n.pdf
Surface proteinsWhat is the function of surface marker proteins li.pdf
Surface proteinsWhat is the function of surface marker proteins li.pdf
2. The CSUN IEEE chapter is to choose a president, treasurer and sec.pdf
2. The CSUN IEEE chapter is to choose a president, treasurer and sec.pdf
of the following choices with has the most water and organic materia.pdf
of the following choices with has the most water and organic materia.pdf
Listed below are blood types for several all possible children and th.pdf
Listed below are blood types for several all possible children and th.pdf
list in order of appearance the four stages of the origin of life an.pdf
list in order of appearance the four stages of the origin of life an.pdf
java programmingAn anonymous class methods cannot access instanc.pdf
java programmingAn anonymous class methods cannot access instanc.pdf
2 which of 1, which two types vnokeetons 6. What s microntuue mad.pdf
2 which of 1, which two types vnokeetons 6. What s microntuue mad.pdf
16) The least expensive form of Internet connection is usually O cabl.pdf
16) The least expensive form of Internet connection is usually O cabl.pdf
i. What does Diaspora means 2 Diaspora peoples refer to who Name th.pdf
i. What does Diaspora means 2 Diaspora peoples refer to who Name th.pdf
How do these primary source images reflect how human societies opera.pdf
How do these primary source images reflect how human societies opera.pdf
How does vesicle budding occurs in yeastDoes the vacuoles uses CopI.pdf
How does vesicle budding occurs in yeastDoes the vacuoles uses CopI.pdf
Recently uploaded
Top five deadliest dog breeds in America
Thinking of getting a dog? Be aware that breeds like Pit Bulls, Rottweilers, and German Shepherds can be loyal and dangerous. Proper training and socialization are crucial to preventing aggressive behaviors. Ensure safety by understanding their needs and always supervising interactions. Stay safe, and enjoy your furry friends!
Best Digital Marketing Institute In NOIDA
Safalta Digital marketing institute in Noida, provide complete applications that encompass a huge range of virtual advertising and marketing additives, which includes search engine optimization, virtual communication advertising, pay-per-click on marketing, content material advertising, internet analytics, and greater. These university courses are designed for students who possess a comprehensive understanding of virtual marketing strategies and attributes.Safalta Digital Marketing Institute in Noida is a first choice for young individuals or students who are looking to start their careers in the field of digital advertising. The institute gives specialized courses designed and certification.
for beginners, providing thorough training in areas such as SEO, digital communication marketing, and PPC training in Noida. After finishing the program, students receive the certifications recognised by top different universitie, setting a strong foundation for a successful career in digital marketing.
Acetabularia Information For Class 9 .docx
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar KanvariaA Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcUnit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is special for master students (MIBS & MIFB) in UUM. Also useful for readers who are interested in the topic of contemporary Islamic banking.
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Discover the Simplified Electron and Muon Model: A New Wave-Based Approach to Understanding Particles delves into a groundbreaking theory that presents electrons and muons as rotating soliton waves within oscillating spacetime. Geared towards students, researchers, and science buffs, this book breaks down complex ideas into simple explanations. It covers topics such as electron waves, temporal dynamics, and the implications of this model on particle physics. With clear illustrations and easy-to-follow explanations, readers will gain a new outlook on the universe's fundamental nature.
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
How to Build a Module in Odoo 17 Using the Scaffold Method
Odoo provides an option for creating a module by using a single line command. By using this command the user can make a whole structure of a module. It is very easy for a beginner to make a module. There is no need to make each file manually. This slide will show how to create a module using the scaffold method.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Recently uploaded (20)
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
How to Build a Module in Odoo 17 Using the Scaffold Method
How to Build a Module in Odoo 17 Using the Scaffold Method
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
Write a function that combines two lists by zipping two lists togeth.pdf
- 1. Write a function that combines two lists by zipping two lists together. Zipping is defined as taking one node from one list and then one from the other list and so on in order to form a single list. After execution, the first list in the original call should point to the combined list (function name: Zip) Solution Hi, Please find my implementation. Please let me know in case of any issue: Node* Zip(Node *head1, Node *head2){ // base case, if head1 is NULL if(head1 == NULL) return head2; // if head2 is NULL if(head2 == NULL) return head1; Node *newHead = NULL; Node current = NULL; // initializing newHead with head1 newHead = head1; // poiniting to head1 newHead->next = head2; current = head2; // forwarding one step head1 = head1->next; head2 = head2->next; while(head1 != NULL && head2 != NULL){ current->next = head1; current->next->next = head2; current = head2; head1 = head1->next; head2 = head2->next; } // copying remaining nodes from head1, if any while(head1 != NULL){
- 2. current->next = head1; current = head1; head1 = head1->next; } // copying remaining nodes from head2, if any while(head2 != NULL){ current->next = head2; current = head2; head2 = head2->next; } return newHead; }