write recursive function that calculates and returns the length of a.pdf
•
0 likes•4 views
write recursive function that calculates and returns the length of a linked list Solution // C code to determine length of linked list recursively #include #include // node of linked list struct node { int key; struct node* next; }; // push key to linked list void push(struct node** root, int new_element) { struct node* nodeNew = (struct node*) malloc(sizeof(struct node)); nodeNew->key = new_element; nodeNew->next = (*root); (*root) = nodeNew; } // recursively get length of linked list int lengthLinkedlist(struct node* root) { // base case if (root == NULL) return 0; // recursively call the function return 1 + lengthLinkedlist(root->next); } int main() { struct node* root = NULL; push(&root, 11); push(&root, 34); push(&root, 4); push(&root, 23); push(&root, 14); push(&root, 88); push(&root, 56); push(&root, 84); push(&root, 6); /* Check the count function */ printf(\"Length of Linked list: %d\ \", lengthLinkedlist(root)); return 0; } /* output: Length of Linked list: 9 */.
Report
Share
Report
Share
Download to read offline
Recommended
Write a C++ function that delete nodes in a doubly linkedlist- It shou.docx
Write a C++ function that delete nodes in a doubly linkedlist.
It should delete all nodes that have that specific value. Finally, return the head of the linkedlist.
node * DN(node *head, int value) {
}
The linkedlist structure:
struct n {
int value;
node *next;
node *previous;
};
Solution
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to delete the entire linked list */
void deleteList(struct node** head_ref)
{
/* deref head_ref to get the real head */
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
free(current);
current = next;
}
/* deref head_ref to affect the real head back
in the caller. */
*head_ref = NULL;
}
/* 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;
}
/* Drier program to test count 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);
printf(\"\ Deleting linked list\");
deleteList(&head);
printf(\"\ Linked list deleted\");
}
.
pleaase I want manual solution forData Structures and Algorithm An.pdf
pleaase I want manual solution for
Data Structures and Algorithm Analysis in C++, Third Edition
By Clifford A. Shaffer
because my question from this book.page270 ,question 7.4
The implementation for Mergesort given in Section 7.4 takes an array as input and sorts that
array. At the beginning of Section 7.4 there is a simple pseudocode implementation for sorting a
linked list using Mergesort. Implement both a linked list-based version of Mergesort and the
array-based version of Mergesort, and compare and analyze their running times.
Solution
Linked list:
#include
#include
struct node
{
int data;
struct node* next;
};
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef);
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
if ((head == NULL) || (head->next == NULL))
{
return;
}
FrontBackSplit(head, &a, &b);
MergeSort(&a);
MergeSort(&b);
*headRef = SortedMerge(a, b);
}
struct node* SortedMerge(struct node* a, struct node* b)
{
struct node* result = NULL;
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
if (a->data <= b->data)
{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if (source==NULL || source->next==NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
while (fast != NULL)
{
fast = fast->next;
if (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
}
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
void push(struct node** head_ref, int new_data)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct node* res = NULL;
struct node* a = NULL;
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);
MergeSort(&a);
printf(\"\ Sorted Linked List is: \ \");
printList(a);
getchar();
return 0;
}
Time complexity:o(nlogn)
Array :
#include
#include
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0; // Initial index of first subarray
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2;
// Sort first and second halves
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
void printArray(int A[], i.
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;
}.
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Use C++ Write a function to merge two doubly linked lists. The input lists have their elements in
sorted order, from lowest to highest. The output list should also be sorted from lowest to highest.
Your algorithm should run in linear time on the length of the output list. Provide an algorithm for
your function Implement and show some samples of your running function
Solution
/* This is a C++ program to merge two sorted linked lists and produce a list in a
Sorted order */
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* This function is used to pull off the front node of the source and put it in destnation */
void letusMoveNode(struct node** destRef, struct node** sourceRef);
/* This is a function used for performing merging of two linked lists.It takes two lists sorted in
increasing order, and splices
their nodes together to make one big sorted list which
is returned. */
struct node* letssortlists(struct node* a, struct node* b)
{
/* Let us first have dummyone first node to hang the result on */
struct node dummyone;
/*next the tail points to the last result node */
struct node* tail = &dummyone;
/* As a result, tail->next is the place to add new nodes
to the result. */
dummyone.next = NULL;
while (1)
{
if (a == NULL)
{
/*we will check that if either list runs out, use the
other list */
tail->next = b;
break;
}
else if (b == NULL)
{
tail->next = a;
break;
}
if (a->data <= b->data)
letusMoveNode(&(tail->next), &a);
else
letusMoveNode(&(tail->next), &b);
tail = tail->next;
}
return(dummyone.next);
}
/* letusMoveNode() function is a function which takes the node from the front of the
source, and move it to the front of the dest.
Before calling letusMoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling letusMoveNode():
source == {3, 4}
dest == {1, 2, 3, 4} */
void letusMoveNode(struct node** destReference, struct node** sourceReference)
{
/*This is the front source node */
struct node* newNode = *sourceReference;
assert(newNode != NULL);
/* now we will advance the source pointer */
*sourceReference = newNode->next;
/*next we will link the old dest off the new node */
newNode->next = *destReference;
/* Fineally we will move dest to point to the new node */
*destReference = newNode;
}
/* This IS A function which is used to insert a node at the beginning of the linked list */
void insertpush(struct node** head_reference, int new_data)
{
/* This is used to allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* now we will put in the data */
new_node->data = new_data;
/* The next step is to link the old list off the new node */
new_node->next = (*head_reference);
/*Finally we will move the head to point to the new node */
(*head_reference) = new_node;
}
/* This is a function to print nodes in a given linked list */
void printList(struct node *node)
{
while (node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/*This is the driver program to test ab.
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
could you implement this function please, im having issues with it..pdf
could you implement this function please, im having issues with it.
void makeList (const ListNode::value_type [],const size_t& count)
class ListNode
{
public:
typedef int value_type;
ListNode (value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }
//Assessor
value_type getDatum () const { return datum; }
ListNode const* getNext () const { return next; }
//Mutator
void setDatum (const value_type& d) {datum = d; }
ListNode* getNext () { return next; }
void setNext (ListNode* new_link) {next = new_link; }
private:
value_type datum;
ListNode* next;
};
class LinkedList
{
public:
LinkedList ();
virtual ~LinkedList ();
void insertItem (ListNode::value_type);
void makeList (const ListNode::value_type [],const size_t& count);
void deleteList ();
//The following friend function is implemented in lablinklist.cpp
friend std::ostream& operator<<(std::ostream&, const LinkedList&);
private:
ListNode* head;
};
This is the pseudocode, but i still have a hard time undertanding it.
Creating a List (makeList(const ListNode::value_type [],const size_t& count)) This function
receives an array in the order that we want to add it to the linkedlist. Index 0 will be the head
node, index n will be the last node.
First, create a node initialized with a data value and a NULL pointer. Set the \"head\" to point to
the first node. Set up a current-pointer to the first node (or \"head\"). Get a data value for the next
node. While more nodes to add { Create a new node initialized with the data value and a NULL
pointer. Set the current-pointer link member (\"next\") to the new node. Set the current-pointer to
point to the new node. Get a data value for the next node. }
Thanks.
Solution
//linkedList.h
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include
#include
class ListNode
{
public:
typedef int value_type;
ListNode(value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }
//Assessor
value_type getDatum() const { return datum; }
ListNode const* getNext() const { return next; }
//Mutator
void setDatum(const value_type& d) { datum = d; }
ListNode* getNext() { return next; }
void setNext(ListNode* new_link) { next = new_link; }
private:
value_type datum;
ListNode* next;
};
class LinkedList
{
public:
LinkedList();
virtual ~LinkedList();
void insertItem(ListNode::value_type);
void makeList(const ListNode::value_type[], const size_t& count);
void deleteList();
//The following friend function is implemented in lablinklist.cpp
friend std::ostream& operator<<(std::ostream&, const LinkedList&);
private:
ListNode* head;
};
#endif
-------------------------------------------------------------
//linkedList.cpp
#include \"linkedlist.h\"
LinkedList::LinkedList()
{
head = NULL;
}
LinkedList::~LinkedList()
{
ListNode *tmp = head;
while (tmp != NULL)
{
head = head->getNext();
delete tmp;
tmp = head;
}
}
void LinkedList::insertItem(ListNode::value_type item)
{
ListNode *newNode,*cur = head;
newNode = new ListNode;
newNode->setDatum(item);
newNode->setNext(NULL);.
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();
}.
Write a C program that reads the words the user types at the command.pdf
Write a C program that reads the words the user types at the command prompt (using the \'int
argc, char * argv[] and store each unique letter in a Binary Search Tree. When a duplicate is
encountered do not store the letter again and instead keep track of the count in the tree. Once the
Binary Search tree has been created print out the tree both inorder and reverse order. Also print
the highest and lowest alphabetically letter in the tree if any.
Solution
# include
# include
# include
typedef struct BST {
int data;
struct BST *lchild, *rchild;
} node;
void insert(node *, node *);
void preorder(node *);
findMinimum(struct node* root)
findMaximum(struct node* root)
void reverseLevelOrder(struct node* root)
void main(int argc,char argv) {
char argv = \'N\';
int key;
node *new_node, *root, *tmp, *parent;
node *get_node();
root = NULL;
clrscr();
printf(\"\ Program For Binary Search Tree \");
do {
printf(\"\ 1.Create\");
printf(\"\ 2.Search\");
printf(\"\ 3.Recursive Traversals\");
printf(\"\ 4.Exit\");
printf(\"\ Enter your choice :\");
scanf(\"%d\", &argc);
switch (argc) {
case 1:
do {
new_node = get_node();
printf(\"\ Enter The Element \");
scanf(\"%d\", &new_node->data);
if (root == NULL) /* Tree is not Created */
root = new_node;
else
insert(root, new_node);
printf(\"\ Want To enter More Elements?(y/n)\");
argv= getch();
} while (argv == \'y\');
break;
case 2:
if (root == NULL)
printf(\"Tree Is Not Created\");
else {
printf(\"\ The Preorder display : \");
preorder(root);
}
break;
}
} while (argv != 4);
}
/*
Get new Node
*/
node *get_node() {
node *temp;
temp = (node *) malloc(sizeof(node));
temp->lchild = NULL;
temp->rchild = NULL;
return temp;
}
/*
This function is for creating a binary search tree
*/
void insert(node *root, node *new_node) {
if (new_node->data < root->data) {
if (root->lchild == NULL)
root->lchild = new_node;
return newNode(key);
else
insert(root->lchild, new_node);
}
if (new_node->data > root->data) {
if (root->rchild == NULL)
root->rchild = new_node;
return newNode(key);
else
insert(root->rchild, new_node);
}
}
if (key == node->key)
{
(node->count)++;
return node;
}
/*
This function displays the tree in preorder fashion
*/
void preorder(node *temp) {
if (temp != NULL) {
printf(\"%d\", temp->data);
preorder(temp->lchild);
preorder(temp->rchild);
}
}
// Returns maximum value in a given Binary Tree
int findMaximum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MAXIMUM;
// Return maximum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMaximum (root->lchild);
int rres = findMaximum (root->rchild);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// Returns minimum value in a given Binary Tree
int findMinimum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MINIMUM;
// Return minimum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMinimum(r.
Recommended
Write a C++ function that delete nodes in a doubly linkedlist- It shou.docx
Write a C++ function that delete nodes in a doubly linkedlist.
It should delete all nodes that have that specific value. Finally, return the head of the linkedlist.
node * DN(node *head, int value) {
}
The linkedlist structure:
struct n {
int value;
node *next;
node *previous;
};
Solution
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to delete the entire linked list */
void deleteList(struct node** head_ref)
{
/* deref head_ref to get the real head */
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
free(current);
current = next;
}
/* deref head_ref to affect the real head back
in the caller. */
*head_ref = NULL;
}
/* 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;
}
/* Drier program to test count 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);
printf(\"\ Deleting linked list\");
deleteList(&head);
printf(\"\ Linked list deleted\");
}
.
pleaase I want manual solution forData Structures and Algorithm An.pdf
pleaase I want manual solution for
Data Structures and Algorithm Analysis in C++, Third Edition
By Clifford A. Shaffer
because my question from this book.page270 ,question 7.4
The implementation for Mergesort given in Section 7.4 takes an array as input and sorts that
array. At the beginning of Section 7.4 there is a simple pseudocode implementation for sorting a
linked list using Mergesort. Implement both a linked list-based version of Mergesort and the
array-based version of Mergesort, and compare and analyze their running times.
Solution
Linked list:
#include
#include
struct node
{
int data;
struct node* next;
};
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef);
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
if ((head == NULL) || (head->next == NULL))
{
return;
}
FrontBackSplit(head, &a, &b);
MergeSort(&a);
MergeSort(&b);
*headRef = SortedMerge(a, b);
}
struct node* SortedMerge(struct node* a, struct node* b)
{
struct node* result = NULL;
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
if (a->data <= b->data)
{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if (source==NULL || source->next==NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
while (fast != NULL)
{
fast = fast->next;
if (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
}
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
void push(struct node** head_ref, int new_data)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct node* res = NULL;
struct node* a = NULL;
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);
MergeSort(&a);
printf(\"\ Sorted Linked List is: \ \");
printList(a);
getchar();
return 0;
}
Time complexity:o(nlogn)
Array :
#include
#include
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0; // Initial index of first subarray
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2;
// Sort first and second halves
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
void printArray(int A[], i.
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;
}.
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Use C++ Write a function to merge two doubly linked lists. The input lists have their elements in
sorted order, from lowest to highest. The output list should also be sorted from lowest to highest.
Your algorithm should run in linear time on the length of the output list. Provide an algorithm for
your function Implement and show some samples of your running function
Solution
/* This is a C++ program to merge two sorted linked lists and produce a list in a
Sorted order */
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* This function is used to pull off the front node of the source and put it in destnation */
void letusMoveNode(struct node** destRef, struct node** sourceRef);
/* This is a function used for performing merging of two linked lists.It takes two lists sorted in
increasing order, and splices
their nodes together to make one big sorted list which
is returned. */
struct node* letssortlists(struct node* a, struct node* b)
{
/* Let us first have dummyone first node to hang the result on */
struct node dummyone;
/*next the tail points to the last result node */
struct node* tail = &dummyone;
/* As a result, tail->next is the place to add new nodes
to the result. */
dummyone.next = NULL;
while (1)
{
if (a == NULL)
{
/*we will check that if either list runs out, use the
other list */
tail->next = b;
break;
}
else if (b == NULL)
{
tail->next = a;
break;
}
if (a->data <= b->data)
letusMoveNode(&(tail->next), &a);
else
letusMoveNode(&(tail->next), &b);
tail = tail->next;
}
return(dummyone.next);
}
/* letusMoveNode() function is a function which takes the node from the front of the
source, and move it to the front of the dest.
Before calling letusMoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling letusMoveNode():
source == {3, 4}
dest == {1, 2, 3, 4} */
void letusMoveNode(struct node** destReference, struct node** sourceReference)
{
/*This is the front source node */
struct node* newNode = *sourceReference;
assert(newNode != NULL);
/* now we will advance the source pointer */
*sourceReference = newNode->next;
/*next we will link the old dest off the new node */
newNode->next = *destReference;
/* Fineally we will move dest to point to the new node */
*destReference = newNode;
}
/* This IS A function which is used to insert a node at the beginning of the linked list */
void insertpush(struct node** head_reference, int new_data)
{
/* This is used to allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* now we will put in the data */
new_node->data = new_data;
/* The next step is to link the old list off the new node */
new_node->next = (*head_reference);
/*Finally we will move the head to point to the new node */
(*head_reference) = new_node;
}
/* This is a function to print nodes in a given linked list */
void printList(struct node *node)
{
while (node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/*This is the driver program to test ab.
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
could you implement this function please, im having issues with it..pdf
could you implement this function please, im having issues with it.
void makeList (const ListNode::value_type [],const size_t& count)
class ListNode
{
public:
typedef int value_type;
ListNode (value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }
//Assessor
value_type getDatum () const { return datum; }
ListNode const* getNext () const { return next; }
//Mutator
void setDatum (const value_type& d) {datum = d; }
ListNode* getNext () { return next; }
void setNext (ListNode* new_link) {next = new_link; }
private:
value_type datum;
ListNode* next;
};
class LinkedList
{
public:
LinkedList ();
virtual ~LinkedList ();
void insertItem (ListNode::value_type);
void makeList (const ListNode::value_type [],const size_t& count);
void deleteList ();
//The following friend function is implemented in lablinklist.cpp
friend std::ostream& operator<<(std::ostream&, const LinkedList&);
private:
ListNode* head;
};
This is the pseudocode, but i still have a hard time undertanding it.
Creating a List (makeList(const ListNode::value_type [],const size_t& count)) This function
receives an array in the order that we want to add it to the linkedlist. Index 0 will be the head
node, index n will be the last node.
First, create a node initialized with a data value and a NULL pointer. Set the \"head\" to point to
the first node. Set up a current-pointer to the first node (or \"head\"). Get a data value for the next
node. While more nodes to add { Create a new node initialized with the data value and a NULL
pointer. Set the current-pointer link member (\"next\") to the new node. Set the current-pointer to
point to the new node. Get a data value for the next node. }
Thanks.
Solution
//linkedList.h
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include
#include
class ListNode
{
public:
typedef int value_type;
ListNode(value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }
//Assessor
value_type getDatum() const { return datum; }
ListNode const* getNext() const { return next; }
//Mutator
void setDatum(const value_type& d) { datum = d; }
ListNode* getNext() { return next; }
void setNext(ListNode* new_link) { next = new_link; }
private:
value_type datum;
ListNode* next;
};
class LinkedList
{
public:
LinkedList();
virtual ~LinkedList();
void insertItem(ListNode::value_type);
void makeList(const ListNode::value_type[], const size_t& count);
void deleteList();
//The following friend function is implemented in lablinklist.cpp
friend std::ostream& operator<<(std::ostream&, const LinkedList&);
private:
ListNode* head;
};
#endif
-------------------------------------------------------------
//linkedList.cpp
#include \"linkedlist.h\"
LinkedList::LinkedList()
{
head = NULL;
}
LinkedList::~LinkedList()
{
ListNode *tmp = head;
while (tmp != NULL)
{
head = head->getNext();
delete tmp;
tmp = head;
}
}
void LinkedList::insertItem(ListNode::value_type item)
{
ListNode *newNode,*cur = head;
newNode = new ListNode;
newNode->setDatum(item);
newNode->setNext(NULL);.
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();
}.
Write a C program that reads the words the user types at the command.pdf
Write a C program that reads the words the user types at the command prompt (using the \'int
argc, char * argv[] and store each unique letter in a Binary Search Tree. When a duplicate is
encountered do not store the letter again and instead keep track of the count in the tree. Once the
Binary Search tree has been created print out the tree both inorder and reverse order. Also print
the highest and lowest alphabetically letter in the tree if any.
Solution
# include
# include
# include
typedef struct BST {
int data;
struct BST *lchild, *rchild;
} node;
void insert(node *, node *);
void preorder(node *);
findMinimum(struct node* root)
findMaximum(struct node* root)
void reverseLevelOrder(struct node* root)
void main(int argc,char argv) {
char argv = \'N\';
int key;
node *new_node, *root, *tmp, *parent;
node *get_node();
root = NULL;
clrscr();
printf(\"\ Program For Binary Search Tree \");
do {
printf(\"\ 1.Create\");
printf(\"\ 2.Search\");
printf(\"\ 3.Recursive Traversals\");
printf(\"\ 4.Exit\");
printf(\"\ Enter your choice :\");
scanf(\"%d\", &argc);
switch (argc) {
case 1:
do {
new_node = get_node();
printf(\"\ Enter The Element \");
scanf(\"%d\", &new_node->data);
if (root == NULL) /* Tree is not Created */
root = new_node;
else
insert(root, new_node);
printf(\"\ Want To enter More Elements?(y/n)\");
argv= getch();
} while (argv == \'y\');
break;
case 2:
if (root == NULL)
printf(\"Tree Is Not Created\");
else {
printf(\"\ The Preorder display : \");
preorder(root);
}
break;
}
} while (argv != 4);
}
/*
Get new Node
*/
node *get_node() {
node *temp;
temp = (node *) malloc(sizeof(node));
temp->lchild = NULL;
temp->rchild = NULL;
return temp;
}
/*
This function is for creating a binary search tree
*/
void insert(node *root, node *new_node) {
if (new_node->data < root->data) {
if (root->lchild == NULL)
root->lchild = new_node;
return newNode(key);
else
insert(root->lchild, new_node);
}
if (new_node->data > root->data) {
if (root->rchild == NULL)
root->rchild = new_node;
return newNode(key);
else
insert(root->rchild, new_node);
}
}
if (key == node->key)
{
(node->count)++;
return node;
}
/*
This function displays the tree in preorder fashion
*/
void preorder(node *temp) {
if (temp != NULL) {
printf(\"%d\", temp->data);
preorder(temp->lchild);
preorder(temp->rchild);
}
}
// Returns maximum value in a given Binary Tree
int findMaximum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MAXIMUM;
// Return maximum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMaximum (root->lchild);
int rres = findMaximum (root->rchild);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// Returns minimum value in a given Binary Tree
int findMinimum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MINIMUM;
// Return minimum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMinimum(r.
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.
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();
}
.
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++: Doubly-Linked Lists
The goal of the exercise is to implement a class List of doubly- linked lists.
My goal is to implement the class in a file doubly-linked.cpp.
The class List implements lists using the following structures for list ele- ments:
struct Node { int val ;
Node next;
Node prev; };
Each Node contains a value (an integer) and two pointers: one meant to point to the next element
of the list and one meant to point to the previous element in the list. The class provides the
following methods that you need to implement:
• A constructor and a destructor, with no arguments;
• void insert(int n): insert an integer at the end of the list;
• void reverse(): reverse the list;
• void print(): print the list to cout in the same format as the input (i.e. integers separated by
spaces);
doubly-linked.h
#ifndef __dll__
#define __dll__
#include
using namespace std;
// Basic structure to store elements of a list
struct Node {
int val; // contains the value
Node * next; // pointer to the next element in the list
Node * prev; // pointer to the previous element in the list
};
// Class List
class List {
public:
List(void); // Constructor
~List(void); // Destructor
void insert(int n); // This should insert n in the list
void reverse(void); // This should reverse the list
void print(void); // This shoiuld print the list
private:
Node * first; // Pointer to the first (if any) element in the list
};
#endif
main.cpp
#include
#include \"doubly-linked.h\"
using namespace std;
int main(void){
List l;
int n;
while(cin >> n){
l.insert(n);
}
// Print list as read from cin
l.print();
// Reverse the list and print it
l.reverse();
l.print();
// Reverse again and print it
l.reverse();
l.print();
return 0;
}
Solution
#include
using namespace std;
/* Linked list structure */
struct list {
struct list *prev;
int data;
struct list *next;
} *node = NULL, *first = NULL, *last = NULL, *node1 = NULL, *node2 = NULL;
class linkedlist {
public:
/* Function for create/insert node at the beginning of Linked list */
void insrt_frnt() {
list *addBeg = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addBeg->data;
if(first == NULL) {
addBeg->prev = NULL;
addBeg->next = NULL;
first = addBeg;
last = addBeg;
cout << \"Linked list Created!\" << endl;
}
else {
addBeg->prev = NULL;
first->prev = addBeg;
addBeg->next = first;
first = addBeg;
cout << \"Data Inserted at the beginning of the Linked list!\" << endl;
}
}
/* Function for create/insert node at the end of Linked list */
void insrt_end() {
list *addEnd = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addEnd->data;
if(first == NULL) {
addEnd->prev = NULL;
addEnd->next = NULL;
first = addEnd;
last = addEnd;
cout << \"Linked list Created!\" << endl;
}
else {
addEnd->next = NULL;
last->next = addEnd;
addEnd->prev = last;
last = addEnd;
cout << \"Data Inserted at the end of the Linked list!\" << endl;
}
}
/* Function for Display Linked list */
void display() {
node = first;
cout << \"List of data in L.
#includestdio.h#includestring.h#includestdlib.h#define M.pdf
#include
#include
#include
#define MAX_STR_LEN 80
//decalring the structure
struct link_node
{
//declaring the variables
char node_str[ MAX_STR_LEN ];
struct link_node *next;
};
//method declaration
typedef struct link_node link_node;
struct link_node *add_node( struct link_node *list,struct link_node *node );
int compare_node( struct link_node *n1, struct link_node *n2 );
void display_list( struct link_node *head );
//implementing the method main
int main()
{
//declaring the main variables
link_node * head=NULL,*temp;
char str[MAX_STR_LEN];
do
{
//getting the STRING input
printf(\"Enter the string : \");
gets(str);
//malloc() is implemented for memory
temp=(link_node*)malloc(sizeof(link_node));
temp->next=NULL;
strcpy(temp->node_str,str);
head=add_node(head,temp);
}while(strlen(str)>1);
display_list(head);
return 0;
}
//method definition for compare node
int compare_node( struct link_node *n1, struct link_node *n2 )
{
if(strcmp(n1->node_str,n2->node_str)==0)
return 0;
if(strcmp(n1->node_str,n2->node_str)<0)
return -1;
else
return 1;
}
//method definition for adding the node
struct link_node *add_node( struct link_node *list,struct link_node *node )
{
link_node *temp=list;
if(list==NULL)
{
return node;
}
if(compare_node(node,list)==-1)
{
node->next=list;
list=node;
return list;
}
else
{
link_node *prev=list;
while(temp!=NULL&&compare_node(node,temp)>=0)
{
prev=temp;
temp=temp->next;
}
prev->next=node;
node->next=temp;
return list;
}
}
//method definition for displaying the list
void display_list( struct link_node *head )
{
link_node *temp;
while(head)
{
printf(\"%s\ \",head->node_str);
temp=head;
head=head->next;
free(temp);
}
}
Sample output:
Enter the string:
Geneva
America
Solution
#include
#include
#include
#define MAX_STR_LEN 80
//decalring the structure
struct link_node
{
//declaring the variables
char node_str[ MAX_STR_LEN ];
struct link_node *next;
};
//method declaration
typedef struct link_node link_node;
struct link_node *add_node( struct link_node *list,struct link_node *node );
int compare_node( struct link_node *n1, struct link_node *n2 );
void display_list( struct link_node *head );
//implementing the method main
int main()
{
//declaring the main variables
link_node * head=NULL,*temp;
char str[MAX_STR_LEN];
do
{
//getting the STRING input
printf(\"Enter the string : \");
gets(str);
//malloc() is implemented for memory
temp=(link_node*)malloc(sizeof(link_node));
temp->next=NULL;
strcpy(temp->node_str,str);
head=add_node(head,temp);
}while(strlen(str)>1);
display_list(head);
return 0;
}
//method definition for compare node
int compare_node( struct link_node *n1, struct link_node *n2 )
{
if(strcmp(n1->node_str,n2->node_str)==0)
return 0;
if(strcmp(n1->node_str,n2->node_str)<0)
return -1;
else
return 1;
}
//method definition for adding the node
struct link_node *add_node( struct link_node *list,struct link_node *node )
{
link_node *temp=list;
if(list==NULL)
{
return node;
}
if(compare_node(node,list)==-1)
{
node->next=list;
list=no.
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
.
maincpp Build and procees a sorted linked list of Patie.pdf
main.cpp
/*
Build and procees a sorted linked list of Patient objects.
The list is sorted in ascending order by name.
Assume that the name is unique.
*/
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <string>
#include <cctype>
#include "LinkedList.h"
using namespace std;
void buildList(const string &filename, LinkedList &list);
void deleteManager(LinkedList &list);
void searchManager(const LinkedList &list);
void displayManager(const LinkedList &list);
int main() {
string inputFileName;
LinkedList list;
cout << "Enter file name: ";
getline(cin, inputFileName);
buildList(inputFileName, list);
displayManager(list);
searchManager(list);
deleteManager(list);
displayManager(list);
return 0;
}
/*
This function reads data from a file and inserts them
into a sorted linked list. The list is sorted in ascending order by name
*/
void buildList(const string &filename, LinkedList &list) {
ifstream inFile(filename);
cout << "Reading data from "" << filename << ""n";
if(!inFile) {
cout << "Error opening the input file: ""<< filename << """ << endl;
exit(EXIT_FAILURE);
}
string id;
int year;
string name;
int amount;
string line;
while (getline(inFile, line)) {
stringstream temp(line);
temp >> id >> year;
temp.ignore();
getline(temp, name, ';');
temp >> amount;
// create a Sales object and initialize it with data from file
/* Write your code here */
// call insert to insert this new Sales object into the sorted list
/* Write your code here */
}
inFile.close();
}
/*
Delete manager: delete items from the list until the user enters Q to quit
deleting
Input Parameter: list
*/
void deleteManager(LinkedList &list) {
string target = "";
cout << " Delete" << endl;
cout << "========" << endl;
while(target != "Q") {
cout << "Enter a name (or Q to stop deleting):" << endl;
getline(cin, target);
target[0] = toupper(target[0]);
if(target != "Q") {
if(list.deleteNode(target))
cout << target << " has been deleted!" << endl;
else
cout << target << " not found!" << endl;
}
}
cout << "___________________END DELETE SECTION_____" << endl;
}
/*
Search manager: search the list until the user enters Q to quit searching
Input Parameter: list
*/
void searchManager(const LinkedList &list) {
string target = "";
Sales obj;
cout << " Search" << endl;
cout << "========" << endl;
/* Write your code here */
cout << "___________________END SEARCH SECTION _____" << endl;
}
/*
Display manager: all, average, or year hired reports including header and footer where
appropriate,
depending on the user's choice;
displays the number of nodes (always)
Input Parameter: list
*/
void displayManager(const LinkedList &list) {
// Sub-functions of displayManager()
void showMenu(void);
string getOption(void);
void showHeader(string line);
string line = "==== ==================== =============n";
string option;
showMenu();
option = getOption();
while(option[0] != 'Q') {
switch (option[0]) {
case 'A':
showHeader(line);
list.displayList();
cout << line;
break;
case 'G':
cou.
Need done for Date Structures please! 4-18 LAB- Sorted number list imp.pdf
Need done for Date Structures please!
4.18 LAB: Sorted number list implementation with linked lists
Step 1: Inspect the Node.h file
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables:
a double data value,
a pointer to the next node, and
a pointer to the previous node.
Each member variable is protected. So code outside of the class must use the provided getter and
setter member functions to get or set a member variable.
Node.h is read only, since no changes are required.
Step 2: Implement the Insert() member function
A class for a sorted, doubly-linked list is declared in SortedNumberList.h. Implement the
SortedNumberList class's Insert() member function. The function must create a new node with
the parameter value, then insert the node into the proper sorted position in the linked list. Ex:
Suppose a SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node
with data value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's
sorted order and yielding: 23 35.5 47.25 86
Step 3: Test in develop mode
Code in main() takes a space-separated list of numbers and inserts each into a SortedNumberList.
The list is displayed after each insertion. Ex: If input is
then output is:
Try various program inputs, ensuring that each outputs a sorted list.
Step 4: Implement the Remove() member function
Implement the SortedNumberList class's Remove() member function. The function takes a
parameter for the number to be removed from the list. If the number does not exist in the list, the
list is not changed and false is returned. Otherwise, the first instance of the number is removed
from the list and true is returned.
Uncomment the commented-out part in main() that reads a second input line and removes
numbers from the list. Test in develop mode to ensure that insertion and removal both work
properly, then submit code for grading. Ex: If input is
then output is:
main.cpp
#include <iostream>
#include <string>
#include <vector>
#include "Node.h"
#include "SortedNumberList.h"
using namespace std;
void PrintList(SortedNumberList& list);
vector<string> SpaceSplit(string source);
int main(int argc, char *argv[]) {
// Read the line of input numbers
string inputLine;
getline(cin, inputLine);
// Split on space character
vector<string> terms = SpaceSplit(inputLine);
// Insert each value and show the sorted list's contents after each insertion
SortedNumberList list;
for (auto term : terms) {
double number = stod(term);
cout << "List after inserting " << number << ": " << endl;
list.Insert(number);
PrintList(list);
}
/*
// Read the input line with numbers to remove
getline(cin, inputLine);
terms = SpaceSplit(inputLine);
// Remove each value
for (auto term : terms) {
double number = stod(term);
cout << "List after removing " << number << ": " << endl;
list.Remove(number.
Program In C You are required to write an interactive C program that.pdf
Program In C You are required to write an interactive C program that prompts the user for
commands, accepts commands from the keyboard (stdin) and executes those commands. When a
command requires output, it must be written to stdout. The program must continue to accept and
process commands until the user types the end command ourput, it must be writen to stdout. The
program must continue to accept and proces.commands The program deals with linked lists.
Each node of such a list contains a string of length at most 10, a positive integer (i.e., an integer
value 2 1) and a pointer to the next node of the list. For any node, the string and the integer
stored in that node will be referred to as the symbol and count for that node respectively. At all
times, the list must satisfy the following two important properties. 1. The symbols appearing in
the list are all distinct; that is, no two nodes have the same symbol. 2. When the list is scanned
from left to right, the counts must be in non-increasing order. An example of such a linked list is
shown below. Search 4 Maxval4 begin/ Loop head
Solution
/**********************************************/
/****** NAMES ******************** COMMANDS ***/
/* Insert Command : ins str */
/* Delete Command : del str */
/* Forced Delete Command : fde val */
/* Print Statistics Command : pst */
/* Print List Command : prl */
/* Print using Count Range Command: pcr v1 v2 */
/* Print Prefix Command : ppr str */
/* Print Suffix Command : psu str */
/* End Command : end */
/***********************************************/
#include
#include
#include
#define CSIZE 4
#define SSIZE 11
/* Struct for each node in the linked list */
struct node
{
int count;
char symbol[SSIZE];
struct node *next;
};
struct node *head;
/* Prototypes for the functions */
void insert(char *);
void delete(char *);
void forced_delete(int value);
void print_stats();
void print_list();
void print_count(int, int);
void print_prefix(char pre[]);
void print_suffix(char suf[]);
void sort_list();
/****************
** Main Method **
****************/
int main(void)
{
int count;
char symbol[SSIZE];
char cmd[CSIZE];
int v1;
int v2;
/* Enter commands */
printf(\"Command? \"); fflush(stdout);
scanf(\"%s\", cmd);
/* Check for command*/
while(strcmp(cmd,\"end\") != 0)
{
/* check which function to use */
if(strcmp(cmd,\"ins\") == 0) { scanf(\"%s\", symbol); insert(symbol); }
if(strcmp(cmd,\"del\") == 0) { scanf(\"%s\", symbol); delete(symbol); }
else if(strcmp(cmd,\"fde\")==0){scanf(\"%d\",&count); forced_delete(count); }
if(strcmp(cmd,\"pst\") == 0) { print_stats();}
if(strcmp(cmd,\"prl\") == 0) { print_list(); }
if(strcmp(cmd,\"pcr\") == 0) { scanf(\"%d %d\",&v1,&v2); print_count(v1,v2); }
if(strcmp(cmd,\"ppr\") == 0) { scanf(\"%s\", symbol); print_prefix(symbol);}
if(strcmp(cmd,\"psu\") == 0) { scanf(\"%s\", symbol); print_suffix(symbol);}
printf(\"Command? \"); fflush(stdout);
scanf(\"%s\", cmd);
}// End of While Loop
return 0;
}// End of main method
/*********.
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
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.
Assignment isPage 349-350 #4 and #5 Use the Linked List lab.pdf
Assignment is:
\"Page 349-350 #4 and #5 Use the \"Linked List lab\" you have been working on in class and add
the two functions the questions are asking you to develop: divideMid and divideAt. Be sure to
include comments Use meaningful identifier names (constants where appropriate) Turn in .cpp
file AND Turn in a \"print-screen\' of your output (press \"print-screen\' on keyboard, then
\'paste\' in MS-Word)\"
How do you solve QUESTION #4 in the book data structures using c++ by D.S. Malik in Visiual
Studios using the linked list below with what is being asked? Please need help
Linked list :
#include
#include
using namespace std;
struct nodeType
{
int info;
nodeType *link;
};
void createList(nodeType*& first, nodeType*& last);
void printList(nodeType*& first);
void insertFront(nodeType*& first);
void insertBack(nodeType*& last);
void deleteFirst(nodeType*& first);
void deleteLast(nodeType*& last, nodeType* first);
int main()
{
nodeType *first, *last;
int num;
createList(first, last);
int choice;
while(true)
{
cout<<\"1. Insert Front.\ 2. Insert Last.\ 3. Delete Front.\ 4. Delete Last.\ 5. Print List.\ 6. Exit.\
\";
cout<<\"Enter your choice: \";
cin>>choice;
switch(choice)
{
case 1: insertFront(first); break;
case 2: insertBack(last); break;
case 3: deleteFirst(first); break;
case 4: deleteLast(last, first); break;
case 5: printList(first); break;
case 6: return 0;
default: cout<<\"Invalid menu option. Try again.\"<>number;
while (number != -999)
{
newNode = new nodeType; // create new node
newNode->info = number;
newNode->link = NULL;
if (first == NULL)
{
first = newNode;
last = newNode;
}
else
{
last->link = newNode;
last = newNode;
}
cout<<\"Enter an integer (-999 to stop): \";
cin>>number;
} // end of while-loop
} // end of build list function
void deleteFirst(nodeType*& first)
{
nodeType *temp;
temp= first;
first= temp->link;
delete temp;
return;
}
void deleteLast(nodeType*& last, nodeType* current)
{
nodeType *temp;
while(current->link != NULL)
{
temp=current;
current=current->link;
}
temp=last;
current->link=NULL;
delete temp;
last = current;
return;
}
void insertFront(nodeType*& front)
{
int num;
cout<<\"\ Enter the number to insert: \";
cin>>num;
nodeType *newNode = new nodeType;
newNode->info=num;
newNode->link= front;
front= newNode;
return;
}
void insertBack(nodeType*& last)
{
int num;
cout<<\"\ Enter the number to insert: \";
cin>>num;
nodeType *newNode = new nodeType;
newNode->info=num;
newNode->link= NULL;
last->link= newNode;
last = newNode;
return;
}
void printList(nodeType*& first)
{
cout<<\"Inside printList...printing linked list...\ \"<info << \" \";
current = current->link;
}
cout<
#include
using namespace std;
struct nodeType
{
int info;
nodeType *link;
};
void createList(nodeType*& first, nodeType*& last);
void printList(nodeType*& first);
void insertFront(nodeType*& first);
void insertBack(nodeType*& last);
void deleteFirst(nodeType*& first);
void deleteLast(nodeType*& last, nodeType* first);
int main()
{
nodeType *firs.
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.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
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;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
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 .
For each task, submit your source java code file.(1) Objective Im.pdf
For each task, submit your source java code file.
(1) Objective: Implement Link List
Write a class that maintains the scores for a game application. Implement the addition and
removal function to update the database. The gamescore.txt contains player’ name and score data
record fields separated by comma. For Removal function, uses the name field to select record to
remove the game score record.
Download – List.java, LList.java, Dlink.java, GameEntry.java, gamescore.txt
(a)Read gamescore.txt to initialize the Linked list in sorted order. (1 point)
(b)Provide Remove and Add function for user to update the sorted linked list. (1 point)
(2)Add a reverse function to the LList.java class to reverse the order of the linked list. (2 points).
---------------------------------------------------------------------------------------------------------------------
-----------------------------------------
//gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
//DLink.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** Doubly linked list node */
class DLink {
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)
{ element = it; prev = p; next = n; }
DLink(DLink p, DLink n) { prev = p; next = n; }
/** Get and set methods for the data members */
DLink next() { return next; }
DLink setNext(DLink nextval)
{ return next = nextval; }
DLink prev() { return prev; }
DLink setPrev(DLink prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
--------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
//GameEntry.java
public class GameEntry {
protected String name;
protected int score;
public GameEntry(String n, int s) {
name = n;
score = s;
}
public String getName() {return name;}
public int getScore() {return score;}
public String toString() {
return \"(\"+name+\",\"+score+\")\";
}
}
--------------------------------------------------------------------------------------------------------------------
----------------------------------
//List.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** List ADT */
public interface List {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
p.
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.
Neutrons cant be detected by the same detectors as alphas, betas, and.pdf
Neutrons cant be detected by the same detectors as alphas, betas, and gammas. Why? Briefly
describe some methods for detecting neutrons.
Solution
Neutron:
The neutron is a subatomic particle, symbol n, with no net electric charge and a mass slightly
larger than that of a proton
Neutron Detection:
Neutrons have mass but no electrical charge. Because of this they cannot directly produce
ionization in a detector, and therefore cannot be directly detected. This means that neutron
detectors must rely upon a conversion process where an incident neutron interacts with a nucleus
to produce a secondary charged particle. These charged particles are then directly detected and
from them the presence of neutrons is deduced.
The most common reaction used for high efficiency thermal neutron detection today is:
n + 3He p + 3H + 765 keV
where both the proton and the triton are detected by a gas filled proportional counters using 3He
fill gas. Quench gas is also added to control the ionization process.
Methods for neutron detection
Gas Proportional detector:
Gas proportional detectors can be adapted to detect neutrons. While neutrons do not typically
cause ionization, the addition of a nuclide with high neutron cross-section allows the detector to
respond to neutrons. Nuclides commonly used for this purpose are helium-3, lithium-6, boron-10
and uranium-235. Since these materials are most likely to react with thermal neutrons (i.e.,
neutrons that have slowed to equilibrium with their surroundings), they are typically surrounded
by moderating materials to reduce their energy and increase the likelihood of detection.
Further refinements are usually necessary to differentiate the neutron signal from the effects of
other types of radiation. Since the energy of a thermal neutron is relatively low, charged particle
reactions are discrete (i.e., essentially monoenergetic and lie within a narrow bandwidth of
energies) while other reactions such as gamma reactions will span a broad energy range, it is
possible to discriminate among the sources.
As a class, gas ionization detectors measure the number (count rate), and not the energy of
neutrons.
Fast neutron detectors
Fast neutrons are often detected by first moderating (slowing) them to thermal energies.
However, during that process the information on the original energy of the neutron, its direction
of travel, and the time of emission is lost. For many applications, the detection of “fret” neutrons
that retain this information is highly desirable
Typical fast neutron detectors are liquid scintillators,[30] 4-He based noble gas detectors and
plastic detectors. Fast neutron detectors differentiate themselves from one another by their 1.)
capability of neutron/gamma discrimination (through pulse shape discrimination) and 2.)
sensitivity. The capability to distinguish between neutrons and gammas is excellent in noble gas
based 4-He detectors due to their low electron density and excellent pulse shape discrimination
propert.
List each hypothesis that is being tested in a twofactor ANOVA.S.pdf
List each hypothesis that is being tested in a twofactor ANOVA.
Solution
In two factor ANOVA there are two independent variables.
Hence the hypothesis are :
1) H01 : Population means of the first factor are equal.
HA1 : Population means of the first factor are not equal.
2) H02 : Population means of the second factor are equal.
HA2 : Population means of the second factor are not equal.
3) H03: There is no interaction between two factors.
HA3 : There is interaction between two factors..
More Related Content
Similar to write recursive function that calculates and returns the length of a.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 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.
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();
}
.
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++: Doubly-Linked Lists
The goal of the exercise is to implement a class List of doubly- linked lists.
My goal is to implement the class in a file doubly-linked.cpp.
The class List implements lists using the following structures for list ele- ments:
struct Node { int val ;
Node next;
Node prev; };
Each Node contains a value (an integer) and two pointers: one meant to point to the next element
of the list and one meant to point to the previous element in the list. The class provides the
following methods that you need to implement:
• A constructor and a destructor, with no arguments;
• void insert(int n): insert an integer at the end of the list;
• void reverse(): reverse the list;
• void print(): print the list to cout in the same format as the input (i.e. integers separated by
spaces);
doubly-linked.h
#ifndef __dll__
#define __dll__
#include
using namespace std;
// Basic structure to store elements of a list
struct Node {
int val; // contains the value
Node * next; // pointer to the next element in the list
Node * prev; // pointer to the previous element in the list
};
// Class List
class List {
public:
List(void); // Constructor
~List(void); // Destructor
void insert(int n); // This should insert n in the list
void reverse(void); // This should reverse the list
void print(void); // This shoiuld print the list
private:
Node * first; // Pointer to the first (if any) element in the list
};
#endif
main.cpp
#include
#include \"doubly-linked.h\"
using namespace std;
int main(void){
List l;
int n;
while(cin >> n){
l.insert(n);
}
// Print list as read from cin
l.print();
// Reverse the list and print it
l.reverse();
l.print();
// Reverse again and print it
l.reverse();
l.print();
return 0;
}
Solution
#include
using namespace std;
/* Linked list structure */
struct list {
struct list *prev;
int data;
struct list *next;
} *node = NULL, *first = NULL, *last = NULL, *node1 = NULL, *node2 = NULL;
class linkedlist {
public:
/* Function for create/insert node at the beginning of Linked list */
void insrt_frnt() {
list *addBeg = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addBeg->data;
if(first == NULL) {
addBeg->prev = NULL;
addBeg->next = NULL;
first = addBeg;
last = addBeg;
cout << \"Linked list Created!\" << endl;
}
else {
addBeg->prev = NULL;
first->prev = addBeg;
addBeg->next = first;
first = addBeg;
cout << \"Data Inserted at the beginning of the Linked list!\" << endl;
}
}
/* Function for create/insert node at the end of Linked list */
void insrt_end() {
list *addEnd = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addEnd->data;
if(first == NULL) {
addEnd->prev = NULL;
addEnd->next = NULL;
first = addEnd;
last = addEnd;
cout << \"Linked list Created!\" << endl;
}
else {
addEnd->next = NULL;
last->next = addEnd;
addEnd->prev = last;
last = addEnd;
cout << \"Data Inserted at the end of the Linked list!\" << endl;
}
}
/* Function for Display Linked list */
void display() {
node = first;
cout << \"List of data in L.
#includestdio.h#includestring.h#includestdlib.h#define M.pdf
#include
#include
#include
#define MAX_STR_LEN 80
//decalring the structure
struct link_node
{
//declaring the variables
char node_str[ MAX_STR_LEN ];
struct link_node *next;
};
//method declaration
typedef struct link_node link_node;
struct link_node *add_node( struct link_node *list,struct link_node *node );
int compare_node( struct link_node *n1, struct link_node *n2 );
void display_list( struct link_node *head );
//implementing the method main
int main()
{
//declaring the main variables
link_node * head=NULL,*temp;
char str[MAX_STR_LEN];
do
{
//getting the STRING input
printf(\"Enter the string : \");
gets(str);
//malloc() is implemented for memory
temp=(link_node*)malloc(sizeof(link_node));
temp->next=NULL;
strcpy(temp->node_str,str);
head=add_node(head,temp);
}while(strlen(str)>1);
display_list(head);
return 0;
}
//method definition for compare node
int compare_node( struct link_node *n1, struct link_node *n2 )
{
if(strcmp(n1->node_str,n2->node_str)==0)
return 0;
if(strcmp(n1->node_str,n2->node_str)<0)
return -1;
else
return 1;
}
//method definition for adding the node
struct link_node *add_node( struct link_node *list,struct link_node *node )
{
link_node *temp=list;
if(list==NULL)
{
return node;
}
if(compare_node(node,list)==-1)
{
node->next=list;
list=node;
return list;
}
else
{
link_node *prev=list;
while(temp!=NULL&&compare_node(node,temp)>=0)
{
prev=temp;
temp=temp->next;
}
prev->next=node;
node->next=temp;
return list;
}
}
//method definition for displaying the list
void display_list( struct link_node *head )
{
link_node *temp;
while(head)
{
printf(\"%s\ \",head->node_str);
temp=head;
head=head->next;
free(temp);
}
}
Sample output:
Enter the string:
Geneva
America
Solution
#include
#include
#include
#define MAX_STR_LEN 80
//decalring the structure
struct link_node
{
//declaring the variables
char node_str[ MAX_STR_LEN ];
struct link_node *next;
};
//method declaration
typedef struct link_node link_node;
struct link_node *add_node( struct link_node *list,struct link_node *node );
int compare_node( struct link_node *n1, struct link_node *n2 );
void display_list( struct link_node *head );
//implementing the method main
int main()
{
//declaring the main variables
link_node * head=NULL,*temp;
char str[MAX_STR_LEN];
do
{
//getting the STRING input
printf(\"Enter the string : \");
gets(str);
//malloc() is implemented for memory
temp=(link_node*)malloc(sizeof(link_node));
temp->next=NULL;
strcpy(temp->node_str,str);
head=add_node(head,temp);
}while(strlen(str)>1);
display_list(head);
return 0;
}
//method definition for compare node
int compare_node( struct link_node *n1, struct link_node *n2 )
{
if(strcmp(n1->node_str,n2->node_str)==0)
return 0;
if(strcmp(n1->node_str,n2->node_str)<0)
return -1;
else
return 1;
}
//method definition for adding the node
struct link_node *add_node( struct link_node *list,struct link_node *node )
{
link_node *temp=list;
if(list==NULL)
{
return node;
}
if(compare_node(node,list)==-1)
{
node->next=list;
list=no.
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
.
maincpp Build and procees a sorted linked list of Patie.pdf
main.cpp
/*
Build and procees a sorted linked list of Patient objects.
The list is sorted in ascending order by name.
Assume that the name is unique.
*/
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <string>
#include <cctype>
#include "LinkedList.h"
using namespace std;
void buildList(const string &filename, LinkedList &list);
void deleteManager(LinkedList &list);
void searchManager(const LinkedList &list);
void displayManager(const LinkedList &list);
int main() {
string inputFileName;
LinkedList list;
cout << "Enter file name: ";
getline(cin, inputFileName);
buildList(inputFileName, list);
displayManager(list);
searchManager(list);
deleteManager(list);
displayManager(list);
return 0;
}
/*
This function reads data from a file and inserts them
into a sorted linked list. The list is sorted in ascending order by name
*/
void buildList(const string &filename, LinkedList &list) {
ifstream inFile(filename);
cout << "Reading data from "" << filename << ""n";
if(!inFile) {
cout << "Error opening the input file: ""<< filename << """ << endl;
exit(EXIT_FAILURE);
}
string id;
int year;
string name;
int amount;
string line;
while (getline(inFile, line)) {
stringstream temp(line);
temp >> id >> year;
temp.ignore();
getline(temp, name, ';');
temp >> amount;
// create a Sales object and initialize it with data from file
/* Write your code here */
// call insert to insert this new Sales object into the sorted list
/* Write your code here */
}
inFile.close();
}
/*
Delete manager: delete items from the list until the user enters Q to quit
deleting
Input Parameter: list
*/
void deleteManager(LinkedList &list) {
string target = "";
cout << " Delete" << endl;
cout << "========" << endl;
while(target != "Q") {
cout << "Enter a name (or Q to stop deleting):" << endl;
getline(cin, target);
target[0] = toupper(target[0]);
if(target != "Q") {
if(list.deleteNode(target))
cout << target << " has been deleted!" << endl;
else
cout << target << " not found!" << endl;
}
}
cout << "___________________END DELETE SECTION_____" << endl;
}
/*
Search manager: search the list until the user enters Q to quit searching
Input Parameter: list
*/
void searchManager(const LinkedList &list) {
string target = "";
Sales obj;
cout << " Search" << endl;
cout << "========" << endl;
/* Write your code here */
cout << "___________________END SEARCH SECTION _____" << endl;
}
/*
Display manager: all, average, or year hired reports including header and footer where
appropriate,
depending on the user's choice;
displays the number of nodes (always)
Input Parameter: list
*/
void displayManager(const LinkedList &list) {
// Sub-functions of displayManager()
void showMenu(void);
string getOption(void);
void showHeader(string line);
string line = "==== ==================== =============n";
string option;
showMenu();
option = getOption();
while(option[0] != 'Q') {
switch (option[0]) {
case 'A':
showHeader(line);
list.displayList();
cout << line;
break;
case 'G':
cou.
Need done for Date Structures please! 4-18 LAB- Sorted number list imp.pdf
Need done for Date Structures please!
4.18 LAB: Sorted number list implementation with linked lists
Step 1: Inspect the Node.h file
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables:
a double data value,
a pointer to the next node, and
a pointer to the previous node.
Each member variable is protected. So code outside of the class must use the provided getter and
setter member functions to get or set a member variable.
Node.h is read only, since no changes are required.
Step 2: Implement the Insert() member function
A class for a sorted, doubly-linked list is declared in SortedNumberList.h. Implement the
SortedNumberList class's Insert() member function. The function must create a new node with
the parameter value, then insert the node into the proper sorted position in the linked list. Ex:
Suppose a SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node
with data value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's
sorted order and yielding: 23 35.5 47.25 86
Step 3: Test in develop mode
Code in main() takes a space-separated list of numbers and inserts each into a SortedNumberList.
The list is displayed after each insertion. Ex: If input is
then output is:
Try various program inputs, ensuring that each outputs a sorted list.
Step 4: Implement the Remove() member function
Implement the SortedNumberList class's Remove() member function. The function takes a
parameter for the number to be removed from the list. If the number does not exist in the list, the
list is not changed and false is returned. Otherwise, the first instance of the number is removed
from the list and true is returned.
Uncomment the commented-out part in main() that reads a second input line and removes
numbers from the list. Test in develop mode to ensure that insertion and removal both work
properly, then submit code for grading. Ex: If input is
then output is:
main.cpp
#include <iostream>
#include <string>
#include <vector>
#include "Node.h"
#include "SortedNumberList.h"
using namespace std;
void PrintList(SortedNumberList& list);
vector<string> SpaceSplit(string source);
int main(int argc, char *argv[]) {
// Read the line of input numbers
string inputLine;
getline(cin, inputLine);
// Split on space character
vector<string> terms = SpaceSplit(inputLine);
// Insert each value and show the sorted list's contents after each insertion
SortedNumberList list;
for (auto term : terms) {
double number = stod(term);
cout << "List after inserting " << number << ": " << endl;
list.Insert(number);
PrintList(list);
}
/*
// Read the input line with numbers to remove
getline(cin, inputLine);
terms = SpaceSplit(inputLine);
// Remove each value
for (auto term : terms) {
double number = stod(term);
cout << "List after removing " << number << ": " << endl;
list.Remove(number.
Program In C You are required to write an interactive C program that.pdf
Program In C You are required to write an interactive C program that prompts the user for
commands, accepts commands from the keyboard (stdin) and executes those commands. When a
command requires output, it must be written to stdout. The program must continue to accept and
process commands until the user types the end command ourput, it must be writen to stdout. The
program must continue to accept and proces.commands The program deals with linked lists.
Each node of such a list contains a string of length at most 10, a positive integer (i.e., an integer
value 2 1) and a pointer to the next node of the list. For any node, the string and the integer
stored in that node will be referred to as the symbol and count for that node respectively. At all
times, the list must satisfy the following two important properties. 1. The symbols appearing in
the list are all distinct; that is, no two nodes have the same symbol. 2. When the list is scanned
from left to right, the counts must be in non-increasing order. An example of such a linked list is
shown below. Search 4 Maxval4 begin/ Loop head
Solution
/**********************************************/
/****** NAMES ******************** COMMANDS ***/
/* Insert Command : ins str */
/* Delete Command : del str */
/* Forced Delete Command : fde val */
/* Print Statistics Command : pst */
/* Print List Command : prl */
/* Print using Count Range Command: pcr v1 v2 */
/* Print Prefix Command : ppr str */
/* Print Suffix Command : psu str */
/* End Command : end */
/***********************************************/
#include
#include
#include
#define CSIZE 4
#define SSIZE 11
/* Struct for each node in the linked list */
struct node
{
int count;
char symbol[SSIZE];
struct node *next;
};
struct node *head;
/* Prototypes for the functions */
void insert(char *);
void delete(char *);
void forced_delete(int value);
void print_stats();
void print_list();
void print_count(int, int);
void print_prefix(char pre[]);
void print_suffix(char suf[]);
void sort_list();
/****************
** Main Method **
****************/
int main(void)
{
int count;
char symbol[SSIZE];
char cmd[CSIZE];
int v1;
int v2;
/* Enter commands */
printf(\"Command? \"); fflush(stdout);
scanf(\"%s\", cmd);
/* Check for command*/
while(strcmp(cmd,\"end\") != 0)
{
/* check which function to use */
if(strcmp(cmd,\"ins\") == 0) { scanf(\"%s\", symbol); insert(symbol); }
if(strcmp(cmd,\"del\") == 0) { scanf(\"%s\", symbol); delete(symbol); }
else if(strcmp(cmd,\"fde\")==0){scanf(\"%d\",&count); forced_delete(count); }
if(strcmp(cmd,\"pst\") == 0) { print_stats();}
if(strcmp(cmd,\"prl\") == 0) { print_list(); }
if(strcmp(cmd,\"pcr\") == 0) { scanf(\"%d %d\",&v1,&v2); print_count(v1,v2); }
if(strcmp(cmd,\"ppr\") == 0) { scanf(\"%s\", symbol); print_prefix(symbol);}
if(strcmp(cmd,\"psu\") == 0) { scanf(\"%s\", symbol); print_suffix(symbol);}
printf(\"Command? \"); fflush(stdout);
scanf(\"%s\", cmd);
}// End of While Loop
return 0;
}// End of main method
/*********.
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
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.
Assignment isPage 349-350 #4 and #5 Use the Linked List lab.pdf
Assignment is:
\"Page 349-350 #4 and #5 Use the \"Linked List lab\" you have been working on in class and add
the two functions the questions are asking you to develop: divideMid and divideAt. Be sure to
include comments Use meaningful identifier names (constants where appropriate) Turn in .cpp
file AND Turn in a \"print-screen\' of your output (press \"print-screen\' on keyboard, then
\'paste\' in MS-Word)\"
How do you solve QUESTION #4 in the book data structures using c++ by D.S. Malik in Visiual
Studios using the linked list below with what is being asked? Please need help
Linked list :
#include
#include
using namespace std;
struct nodeType
{
int info;
nodeType *link;
};
void createList(nodeType*& first, nodeType*& last);
void printList(nodeType*& first);
void insertFront(nodeType*& first);
void insertBack(nodeType*& last);
void deleteFirst(nodeType*& first);
void deleteLast(nodeType*& last, nodeType* first);
int main()
{
nodeType *first, *last;
int num;
createList(first, last);
int choice;
while(true)
{
cout<<\"1. Insert Front.\ 2. Insert Last.\ 3. Delete Front.\ 4. Delete Last.\ 5. Print List.\ 6. Exit.\
\";
cout<<\"Enter your choice: \";
cin>>choice;
switch(choice)
{
case 1: insertFront(first); break;
case 2: insertBack(last); break;
case 3: deleteFirst(first); break;
case 4: deleteLast(last, first); break;
case 5: printList(first); break;
case 6: return 0;
default: cout<<\"Invalid menu option. Try again.\"<>number;
while (number != -999)
{
newNode = new nodeType; // create new node
newNode->info = number;
newNode->link = NULL;
if (first == NULL)
{
first = newNode;
last = newNode;
}
else
{
last->link = newNode;
last = newNode;
}
cout<<\"Enter an integer (-999 to stop): \";
cin>>number;
} // end of while-loop
} // end of build list function
void deleteFirst(nodeType*& first)
{
nodeType *temp;
temp= first;
first= temp->link;
delete temp;
return;
}
void deleteLast(nodeType*& last, nodeType* current)
{
nodeType *temp;
while(current->link != NULL)
{
temp=current;
current=current->link;
}
temp=last;
current->link=NULL;
delete temp;
last = current;
return;
}
void insertFront(nodeType*& front)
{
int num;
cout<<\"\ Enter the number to insert: \";
cin>>num;
nodeType *newNode = new nodeType;
newNode->info=num;
newNode->link= front;
front= newNode;
return;
}
void insertBack(nodeType*& last)
{
int num;
cout<<\"\ Enter the number to insert: \";
cin>>num;
nodeType *newNode = new nodeType;
newNode->info=num;
newNode->link= NULL;
last->link= newNode;
last = newNode;
return;
}
void printList(nodeType*& first)
{
cout<<\"Inside printList...printing linked list...\ \"<info << \" \";
current = current->link;
}
cout<
#include
using namespace std;
struct nodeType
{
int info;
nodeType *link;
};
void createList(nodeType*& first, nodeType*& last);
void printList(nodeType*& first);
void insertFront(nodeType*& first);
void insertBack(nodeType*& last);
void deleteFirst(nodeType*& first);
void deleteLast(nodeType*& last, nodeType* first);
int main()
{
nodeType *firs.
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.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
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;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
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 .
For each task, submit your source java code file.(1) Objective Im.pdf
For each task, submit your source java code file.
(1) Objective: Implement Link List
Write a class that maintains the scores for a game application. Implement the addition and
removal function to update the database. The gamescore.txt contains player’ name and score data
record fields separated by comma. For Removal function, uses the name field to select record to
remove the game score record.
Download – List.java, LList.java, Dlink.java, GameEntry.java, gamescore.txt
(a)Read gamescore.txt to initialize the Linked list in sorted order. (1 point)
(b)Provide Remove and Add function for user to update the sorted linked list. (1 point)
(2)Add a reverse function to the LList.java class to reverse the order of the linked list. (2 points).
---------------------------------------------------------------------------------------------------------------------
-----------------------------------------
//gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
//DLink.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** Doubly linked list node */
class DLink {
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)
{ element = it; prev = p; next = n; }
DLink(DLink p, DLink n) { prev = p; next = n; }
/** Get and set methods for the data members */
DLink next() { return next; }
DLink setNext(DLink nextval)
{ return next = nextval; }
DLink prev() { return prev; }
DLink setPrev(DLink prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
--------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
//GameEntry.java
public class GameEntry {
protected String name;
protected int score;
public GameEntry(String n, int s) {
name = n;
score = s;
}
public String getName() {return name;}
public int getScore() {return score;}
public String toString() {
return \"(\"+name+\",\"+score+\")\";
}
}
--------------------------------------------------------------------------------------------------------------------
----------------------------------
//List.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** List ADT */
public interface List {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
p.
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.
Similar to write recursive function that calculates and returns the length of a.pdf (20)
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
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
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
#includestdio.h#includestring.h#includestdlib.h#define M.pdf
#includestdio.h#includestring.h#includestdlib.h#define M.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
maincpp Build and procees a sorted linked list of Patie.pdf
maincpp Build and procees a sorted linked list of Patie.pdf
Need done for Date Structures please! 4-18 LAB- Sorted number list imp.pdf
Need done for Date Structures please! 4-18 LAB- Sorted number list imp.pdf
Program In C You are required to write an interactive C program that.pdf
Program In C You are required to write an interactive C program that.pdf
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
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
Assignment isPage 349-350 #4 and #5 Use the Linked List lab.pdf
Assignment isPage 349-350 #4 and #5 Use the Linked List lab.pdf
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
C++ Please write the whole code that is needed for this assignment- wr.docx
C++ Please write the whole code that is needed for this assignment- wr.docx
C code on linked list #include stdio.h #include stdlib.h.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
For each task, submit your source java code file.(1) Objective Im.pdf
For each task, submit your source java code file.(1) Objective Im.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
More from arpitcomputronics
Neutrons cant be detected by the same detectors as alphas, betas, and.pdf
Neutrons cant be detected by the same detectors as alphas, betas, and gammas. Why? Briefly
describe some methods for detecting neutrons.
Solution
Neutron:
The neutron is a subatomic particle, symbol n, with no net electric charge and a mass slightly
larger than that of a proton
Neutron Detection:
Neutrons have mass but no electrical charge. Because of this they cannot directly produce
ionization in a detector, and therefore cannot be directly detected. This means that neutron
detectors must rely upon a conversion process where an incident neutron interacts with a nucleus
to produce a secondary charged particle. These charged particles are then directly detected and
from them the presence of neutrons is deduced.
The most common reaction used for high efficiency thermal neutron detection today is:
n + 3He p + 3H + 765 keV
where both the proton and the triton are detected by a gas filled proportional counters using 3He
fill gas. Quench gas is also added to control the ionization process.
Methods for neutron detection
Gas Proportional detector:
Gas proportional detectors can be adapted to detect neutrons. While neutrons do not typically
cause ionization, the addition of a nuclide with high neutron cross-section allows the detector to
respond to neutrons. Nuclides commonly used for this purpose are helium-3, lithium-6, boron-10
and uranium-235. Since these materials are most likely to react with thermal neutrons (i.e.,
neutrons that have slowed to equilibrium with their surroundings), they are typically surrounded
by moderating materials to reduce their energy and increase the likelihood of detection.
Further refinements are usually necessary to differentiate the neutron signal from the effects of
other types of radiation. Since the energy of a thermal neutron is relatively low, charged particle
reactions are discrete (i.e., essentially monoenergetic and lie within a narrow bandwidth of
energies) while other reactions such as gamma reactions will span a broad energy range, it is
possible to discriminate among the sources.
As a class, gas ionization detectors measure the number (count rate), and not the energy of
neutrons.
Fast neutron detectors
Fast neutrons are often detected by first moderating (slowing) them to thermal energies.
However, during that process the information on the original energy of the neutron, its direction
of travel, and the time of emission is lost. For many applications, the detection of “fret” neutrons
that retain this information is highly desirable
Typical fast neutron detectors are liquid scintillators,[30] 4-He based noble gas detectors and
plastic detectors. Fast neutron detectors differentiate themselves from one another by their 1.)
capability of neutron/gamma discrimination (through pulse shape discrimination) and 2.)
sensitivity. The capability to distinguish between neutrons and gammas is excellent in noble gas
based 4-He detectors due to their low electron density and excellent pulse shape discrimination
propert.
List each hypothesis that is being tested in a twofactor ANOVA.S.pdf
List each hypothesis that is being tested in a twofactor ANOVA.
Solution
In two factor ANOVA there are two independent variables.
Hence the hypothesis are :
1) H01 : Population means of the first factor are equal.
HA1 : Population means of the first factor are not equal.
2) H02 : Population means of the second factor are equal.
HA2 : Population means of the second factor are not equal.
3) H03: There is no interaction between two factors.
HA3 : There is interaction between two factors..
Marla begins walking at 3 mih toward the library.Her friend meets h.pdf
Marla begins walking at 3 mi/h toward the library.Her friend meets her at the halfway point and
drives her the rest of the way to the library.The distance to the library is 4 miles.How many hours
did Marla Walk.
Solution
Maria Walking DATA:
rate = 3 mph ; distance = 2 miles
--------------------
Equation:
time = distance/rate = 2/3 hr.
Mrs. S confides in you that she is terrified of her husband. She rep.pdf
Mrs. S confides in you that she is terrified of her husband. She reports that at times, he is so kind,
and then later he is angry and has become physically abusive at times. She also reports that he
frequently wakes up at night screaming and trying to crawl under the bed.
1.) What does the nurse suspect?
Additional questioning reveals that Mr. S has just returned to the United States following a 3-
year deployment in the military. You strongly recommend that Mr. S see a health care provider
as soon as possible.
1.) What questions might be helpful in identifying the cause of these manifestations?
2.) What other manifestations would make the nurse suspect PTSD?
3.) What three criteria must be met to confirm the diagnosis of PTSD?
4.) Other than combat, what are some other causes of PTSD?
Solution
Ans:
1.) What does the nurse suspect?
In the above case, Since Mr. S was in the military and might have undergone life threatening
events. Based on his reactions and his wife statements, nurse suspect that, Mr. S is under
depression ie., Posttraumatic Stress Disorder (PSTD).
PSTD: Is a psychiatric disorder that can occur following the experience or witnessing of a life-
threatening events such as military combat, natural disasters, terrorist incidents, serious
accidents, or physical or sexual assault in adult or childhood.
It\'s natural to experience fear in dangerous situations. But people with PTSD may behave as
though they are under attack when there is no real imminent threat.
A person who suffers PTSD typically re-experiences the trauma through flashbacks and
nightmares, experiences that can seem as real as the actual trauma. The person often feels
intensely that the trauma could happen again at any time.
Thoughts and feelings can trigger symptoms, but so can words, situations or objects that remind
the person of a traumatic situation.
2).What questions might be helpful in identifying the cause of these manifestations?
The first step in diagnosing trauma is making an appointment with a doctor, preferably someone
trained in mental health disorders. The doctor will talk with the patient to determine their state of
mind. The practitioner will have to determine whether the prerequisite symptoms for PTSD are
present before deciding how to proceed. For a diagnosis of PTSD, the patient must have
experienced the following for at least one month:
· 3). What other manifestation would make the nurse suspect PTSD?
Since Mr. S was in the military and might have undergone life threatening events. Based on his
reactions and his wife statements, nurse suspect that, Mr. S is under depression ie., Posttraumatic
Stress Disorder (PSTD).
4).What three criteria must be met to confirm the diagnosis of PTSD?
Currently, diagnosis of PTSD is based on 8 criteria
1) The first criterion has 4 components, as follows:
2) The second criterion involves the persistent re experiencing of the event in 1 of several ways:
Unlike adults, children reexperience the event through repetiti.
In September of 2008, the FDIC paid JP Morgan Chase to purchase all .pdf
In September of 2008, the FDIC paid JP Morgan Chase to purchase all of the assets of and
assume all of the liabilities of Washington Mutual Bank. This was an outright bailout of a private
company by the FDIC. What makes this more problematic is that uninsured creditors were
compensated by the FDIC. T or F?
Solution
The statement is false. The uninsured creditors were not compensated in this transaction. In fact,
uninsured depositors were benefitted from this transaction..
In cocker spaniels, black coat color (B) is dominant over red (b), an.pdf
In cocker spaniels, black coat color (B) is dominant over red (b), and solid color (S) is dominant
over spotted (s). If a red spotted male were crossed to a black solid female and all the offspring
from several crosses showed only the dominant traits, the geneotype of the parents would most
likely be Bb Ss times Bb Ss. bb ss times Bb Ss. bb Ss times Bb SS. bb ss times BB SS. Bb ss
times BB SS.
Solution
Answer: (d) bbss x BBSS
P1=
bbss (Male) x BBSS (female)
F1= BbSs ( black and solid)
All the offsprings will be black and solid (both the traits being dominant).
In most healthy people, toxoplasmosis is an inapparent or mild dise.pdf
In most healthy people, toxoplasmosis is an inapparent or mild disease Name two groups of
people who need to be concerned about serious disease or consequences from an infection with
this parasite and why they need to be concerned.
Solution
A single-celled parasite called Toxoplasma gondii causes toxoplasmosis.
Groups of people who are more concerned about toxoplasmosis include:
-babies born to mothers who\'re newly inflamed with Toxoplasma gondii during or before
pregnancy.
-people with seriously weakened immune structures, which include individuals with AIDS, the
ones taking certain forms of chemotherapy, and people who have recently obtained an organ
transplant.
Why these group of people are more concerned and what are the consequences of toxoplasmosis
:
-A woman who got toxoplasmosis before getting pregnant usually won\'t pass the infection to
the baby — this is because she will have built up immunity to the infection. But it can come back
and has a weakened immune system.
- the threat for intense troubles in pregnancy are: premature birth, low beginning weight, fever,
jaundice, abnormalities of the retina, intellectual retardation, extraordinary head length,
convulsions, and brain calcification.
-toxoplasmosis can have lasting effects at the:
brain
eyes
heart
lungs
-Some babies with congenital toxoplasmosis have brain and nervous system problems ..
I only need help with four methods in the EmployeeManager class the .pdf
I only need help with four methods in the EmployeeManager class the methods are addRequest,
viewNextRequest, grantNextRequest, and outputRequests. I posted all of the other uml for
refernce on items that could be called.
UML DIAGRAM FOR AND DISCUSSION FOR EmptyListException
EmptyListException extends RuntimeException
<>EmptyListException( )
<>EmptyListException(name : String)
Constructors
The constructor that takes a String as an argument calls upon the super class constructor with that
String concatenated with “ is Empty”. The constructor that takes no argument calls upon the
other constructor with the argument of “List”.
This class should belong to the exceptions package.
UML DIAGRAM FOR AND DISCUSSION FOR ListNode
ListNode>
data : E
nextNode: ListNode
<>ListNode(d : E)
<>ListNode(d : E, node : ListNode)
+ setData(d : E)
+getData() : E
+setNext(next : ListNode)
+getNext() : ListNode
Notes on ListNode
ListNode(d : E) sets the nextNode to null, the rest of the implementation of the ListNode class is
self-explanatory as discussed in class
UML DIAGRAM FOR AND DISCUSSION FOR LinkedList
LinkedList>
firstNode : ListNode
lastNode : ListNode
numElements : int
name : String
<>LinkedList()
<>LinkedList(name : String)
+ insertAtFront(item : E)
+ insertAtBack(item : E)
+ removeFromFront() : E throws EmptyListException
+ removeFromBack() : E throws EmptyListException
+ removeItem(index : int) : E throws IndexOutOfBoundsException
+ getItem(index : int) : E throws IndexOutOfBoundsException
+ setItem(index : int, item : E) throws IndexOutOfBoundsException
+ findAndRemove(item : E) : Boolean
+ findItem(item E) : int
+ lengthIs() : int
+ clear()
+ toString()
+ isEmpty() : Boolean
+ sort() throws EmptyListException
Notes on LinkedList
Constructors
Both constructors set firstNode and lastNode to null and numElements to 0. The constructor that
takes a String sets the name data member to the String that is passed
insertAtFront(E)
Inserts the passed item to the front of the list
void insertAtBack(E)
Inserts the passed item in the back of the list
void removeFromFront()
Removes the first item in the list, and returns it. If the list is empty throws a new
EmptyListException with the message: “(Name of list) is Empty”
removeFromBack()
Removes the last item in the list, and returns it. If the list is empty throws a new
EmptyListException with the message: “(Name of list) is Empty”
removeItem(int)
Removes the element from the list at the given index. If that index does not exist within the
LinkedList an IndexOutOfBoundsException is thrown with the message: “(Name of List) Index
out of Range”. Returns the item removed.
getItem(int)
Returns the element at the given index. If that index does not exist within the LinkedList an
IndexOutOfBoundsException is thrown with the message: “(Name of List) Index out of Range”.
public setItem(int index, E item)
Attempts to place the passed item into the given index. If that index does not exist within the
LinkedList an IndexOutOfBound.
Identify and briefly describe a diffusion network that you have expe.pdf
Identify and briefly describe a diffusion network that you have experienced, weaving support /
information from our readings with your own professional practice and application.
Solution
Diffusion is the process in which an innovation is communicated through certain channels over
time among members of a social system. It is a special type of communications in that the
messages are concerned with new ideas.
There are four main elements are the innovation, communication channels, time, and the social
system.
Model of Diffusion:
Crucial for diffusion in networks, but all kinds of behaviors have their unique properties.
Diffusion = network(t)
Network(t)= network model of system constitutes diffusion environment
PSM- Probabilistic finite-state machine model of considered behavior.
(such as information, virus,etc )
Generator V(t) => SIG - specific function for simulation needs (generator of signals). Which
assigns for each vertex in each simulations step a set of signals as a result of vertices first
neighborhood and their states.
These signals are received and processed by PSM on each vertex..
how do the masses of the earth, oceans, atmosphere, and biosphere co.pdf
how do the masses of the earth, oceans, atmosphere, and biosphere compare?
Solution
The hydrosphere is a characterizing normal for the Earth. It is the main planet in the Solar
System with a hydrological cycle. This incorporates: seas; freshwater (streams, lakes, and
groundwater); and the cryosphere (where water exists as a strong – ice or snow –, for example,
inside ice sheets, ice sheets and permafrost/solidified ground. These are likewise significant
stores of freshwater). The hydrosphere and cryosphere are likewise much of the time perceived
as two separate \'circles\'. Together, these water sources are essential for all types of life on
Earth, and they are the reason that Earth is regularly named the \'water planet\'.
The air is the thick layer of vaporous material which encompasses the Earth. The greater part of
the environment exists in 97 km of the Earth\'s surface, yet it has no unequivocal limit. The air is
isolated into four layers, the Troposphere (0-10 km elevation), the Stratosphere (10-45 km
height), the Mesosphere (45-80 km height), and the Thermosphere (80-300 km elevation). The
environment involves: 78.09% nitrogen, 20.95% oxygen, 0.93% argon, 0.039% carbon dioxide
and little measures of different gasses. These gasses are regularly named \'nursery gasses\' as
they are gently adjusted to keep up the Earth\'s temperature at a level appropriate to maintain life.
Without these gasses, and the regular nursery impact, the normal temperature of the Earth would
be around - 18°C (0°F) rather than its current 14°C (57°F).Earth is one of only a handful couple
of planets in the nearby planetary group which has an air. Venus, one of our nearest neighbors
has an environment made of 96.5% carbon dioxide (CO2) and 3.5% nitrogen (N2), which frames
an extremely harmful climate, permitting it to keep up a sweltering surface temperature of
467°C!
The lithosphere is the term given to the stone and minerals which shape Earth\'s external outside
and its structural plates. This is a critical part of the Earth\'s framework as these stones get to be
distinctly disintegrated and weathered to give essential minerals to the next Earth frameworks.
Through Earth\'s history, the whole lithosphere has been reused roughly six circumstances. At
the peripheral layer of the lithosphere, the \"pedosphere\" (which means soil circle) exists at the
interface between lithospheric, air, biospheric and hydrospheric forms. The blend of these
procedures prompts to soil arrangement, which is basic for maintaining life on Earth (the
biosphere).
The biosphere alludes to a wide range of life on Earth, including plants, creatures, and
microscopic organisms. Over the historical backdrop of the Earth the biosphere has changed
significantly with an awesome number of animal types developing, adjusting, and getting to be
distinctly wiped out. The differing qualities of the biosphere fluctuates extraordinarily over the
Earth, as species can be very helpless against even minor vari.
If the mechanism of DNA replication (semi-conservative, conservative.pdf
If the mechanism of DNA replication (semi-conservative, conservative, and dispersive) was not
yet known:
a. What experiment(s) could distinguish between the three possible mechanisms. Explain how
this method can distinguish between the 3 models.
b. Compare your experiment with the original mechanism. What are the advantages,
disadvantages to each
Solution
If the DNA replication mechanism is not yet known Messelson-Stahl experiment set forward to
distinguish the three mechanisms; conservative, semi- conservative and dispersive mode of
replication.
Messelson-Stahl experiment model used non radioactive heavy isotope of Nitrogen as they found
nitrogen is abundant element in DNA. They labelled the DNA of E.coli bacteria with heavy
isotope 15N and grew in a medium. Soon after many generations 15N labelled DNA were
synthesised. Then they removed the 15N labelled DNA from the medium and placed in normal
14N medium. The cells were then extracted from this medium and were placed in CsCl solution
and are centrifused..
EYCONNEC Cell Structures the arrangement of phospholipids in the plas.pdf
EYCONNEC Cell Structures the arrangement of phospholipids in the plasma membrane 2. helps
make and transport proteins and lipids 3. stores and transports protein and lipid molecules 4.
helps the cell maintain itsshape and holds cell organelles in place within the cytoplasm of a plant
cell layer that samoundsthe Plasma membrane help organize the chromosomes before cell
division the cell 7. organene that processes proteins and prepares them for use both inside and
outside larger of the sac-like organelles that store and transport materials in the cem 9. describes
the formation of eukaryotic cells 10, eneray carrying molecule 11. stores substances such as
water, and salts in plant cells enzymes, 12.-power plann of the cell a, ATP b cell wall c, central
vacuole endoplasmic reticulum g. endosymbiotic theory h. Golgi apparatus mitochondria
phospholipid bilayer vesicle Lesson 3.2: Vocabulary ll Name Class Date Fill in the blank with
the appropriate tem. is often considered to be the cell\'s control center. 1, The 2 The consists of
everything inside the plasma membrane of the cell. 3. The plasma membrane forms a between
the inside and outside of the cell 4, The is essentially a \"skeleton\" inside the cell.
Solution
1->j)phospholid bilayer->the arrangement of phospholipids in the plasma membrane
2.->f)endoplasmic reticulum->Helps make and transport protein and lipid molecules
3.l)->vesicle->Stores and transports protein and lipid molecules
4)e)cytoskeleton->Helps the cell maintain it\'s shape and holds cell organelles in place within the
cytoplasm
5)b)cell wall->Layer that surrounds the plasma membrane of a plant cell
6)d)centriole->help organize the chromosomes before cell division
7)h)Golgi apparatus->Organelle that processes protein and prepares them for use both inside and
outside the cell
8)k)vacuole->Larger of the sac-like organelles that store and transport materials in the cell
9)g)endosymbiotic theory->Describes the formation of eukaryotic cells
10)a)ATP->energy carrying molecule
11)c)central vacuole->Stores substances such as water, enzymes, and salt in plant cells
12)i)mitochondria->\"Power plant\" of the cell.
For the balance sheet, please categorize the following as short-term.pdf
For the balance sheet, please categorize the following as short-term assets, long-term assets,
short-term liabilities, long-term liabilities, or owner’s equity:
Cash, accruals, property, plant and equipment, inventory, accounts receivables, paid in capital,
retained earnings, notes payable, mortgage, and accounts payable.
Solution
short term assets=cash,inventory,account receivables, accrued revenues
long term assets= property,plant and equipment
short term liabilities= accounts payable,accrued expenses, notes payable (if amount due within
one year of the balance sheet date)
long term liabilities= mortgage, notes payable ( if amount not due within one year of the balance
sheet date)
owners equity = paid in capital, retained earning.
During World War II, the Manhattan Project developed the first nuclea.pdf
During World War II, the Manhattan Project developed the first nuclear weapon and detonated it
in 1945 at the Trinity test. The explosive yield of the bomb was classified by the U.S. Army;
however, in 1950 British physicist Sir Geoffrey Taylor made a good estimate of the yield based
on publicly available photographs and data. He developed an equation that linked several key
test and used it to calculate the yield: R = S (Et^2/rho)^1/5 R is the blast radius in meters; t is
seconds after the detonation, rho (the Greek letter rho) is the air density at the blast site; S is a
constant describing the heat capacity of the air; and E is the energy released by the bomb in
joules. (1 joule (J) = 1 kg middot m^2/s^2). From the available atmospheric data, Taylor
concluded that S = 1.041 and rho = 1.00 kg/m^3. By studying a picture of the blast taken at t =
0.025, the estimated that the blast radius was 140 similar meters. Explosive yield is often
described by how much TNT would be required to produce a similar explosion. The explosive
force of 1 kiloton (kt) of TNT is approximately 4.184 Times 10^12 joules. Rearrange Taylor\'s
equation to give you a formula for the yield of the bomb in kilotons. Calculate the yield of the
Trinity bomb to the nearest kiloton. Taylor\'s estimate was lower than the actual yield of 20.08
kilotons. Which quantities might he have underestimated when using them in his equations?
Which might he have overestimated?
Solution
Reason
Short information.
Deoxy sugars are modified sugars where one or more OH groups are remo.pdf
Deoxy sugars are modified sugars where one or more OH groups are removed from a carbon.
For example, deoxyribose is a deoxy form of ribose. However, as a result, deoxy sugars often
can have multiple names that describe the same molecule. Find alternate names for the for the
following deoxy sugars:
Solution
1. 2-deoxy-mannose->2-Deoxy-glucose
2.2-deoxy-arabinose->deoxypentose
3.3-deoxy-psicose->D-Psicose
4.3-deoxy-xylucose->1-Deoxy-2-pentulose
5.3-deoxy-talose-> 3-amino-3-deoxy-l-talose.
Determine truth value of the statement. Domain consists of all real .pdf
Determine truth value of the statement. Domain consists of all real numbers. Please explain I do
not understand with nested.
a) xy(x^2 = y)
b) xy(x = y^2)
Solution
a) says that for every x there exists a y, Its True. Since there is only 1 y for every x
b) says that for every x there exists a y, Its False. Since there are no y`s for negative x.
Describe the niches of at least 3 species of wildlife that might be .pdf
Describe the niches of at least 3 species of wildlife that might be found in Michigan.
Solution
The forest landscape of Michigan represents wide variety of species. The land is mostly occupied
by red wood trees and shaded land is dominated by ferns. The trees support wide species of wild
life. The fallen logs in the forest support Salamanders, snakes, flying squirrels, small insects and
several invertebrates.
The downy and hairy woodpeckers live on dying and dead standing trees known as snags. The
hairy woodpeckers require larger snags than down woodpeckers. The trees provide food for
insects and shelter. The hairy woodpeckers feed on large insects. These small differences in
habitats are observed between downy and hairy woodpeckers. Each type of woodpecker occupies
a different niche and exhibits different functional role in the forest ecosystem.
Two types of forests are abudant. Coniferous forests are habitat for Red squirrels that feed on
large pine cones. The deciduous forests are habitat of grey squirrels. These feed on acorns and
beechnuts.
Amphibians like redbacked and spotted salamanders live in moist, mature deciduous forest floors
and at dead and decaying logs. Red shouldered hawks are found extensively in deciduous forest
types and use lowland for nesting.
Several types of birds, insects, reptiles, amphibians, squirrels, black bears and various types of
fungi and mushrooms live in different ecological niches in the Michigan forests..
Define multicollinearity in the following termsa. In which type o.pdf
Define multicollinearity in the following terms:
a. In which type of regression is it likely to occur?
Solution
Collinearity is a linear association between two explanatory variables.
Two variables are perfectly collinear if there is an exact linear relationship between them.
Multicollinearity is a phenomenon in which two or more predictor variables in a multiple
regression model are highly correlated, means that one can be linearly predicted from the others
with a substantial degree of accuracy
Hence multi collinearity occurs in multiple regression.
Convert the for loop Into MIPS Instructions. Use the sit instruction .pdf
Convert the for loop Into MIPS Instructions. Use the sit instruction to determine the branch. Be
sure to Initialize I properly. for (Int I = 1; I min &&i;>l; Else A[i] = 0; I: $t0, min: $t1, max:
$t2, base address of A: $s0
Solution
Answer:
a)
.zero 1
main:
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-8], 1
.L3:
cmp DWORD PTR [rbp-8], 6
jg .L2
mov eax, DWORD PTR [rbp-8]
add DWORD PTR [rbp-4], eax
add DWORD PTR [rbp-8], 1
jmp .L3
.L2:
mov eax, 0
pop rbp
ret
__static_initialization_and_destruction_0(int, int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
cmp DWORD PTR [rbp-4], 1
jne .L7
cmp DWORD PTR [rbp-8], 65535
jne .L7
mov edi, OFFSET FLAT:std::__ioinit
call std::ios_base::Init::Init()
mov edx, OFFSET FLAT:__dso_handle
mov esi, OFFSET FLAT:std::__ioinit
mov edi, OFFSET FLAT:std::ios_base::Init::~Init()
call __cxa_atexit
.L7:
nop
leave
ret
push rbp
mov rbp, rsp
mov esi, 65535
mov edi, 1
call __static_initialization_and_destruction_0(int, int)
pop rbp
ret
b)
.zero 1
main:
push rbp
mov rbp, rsp
mov eax, DWORD PTR [rbp-4]
cmp eax, DWORD PTR [rbp-8]
jle .L2
mov eax, DWORD PTR [rbp-4]
cmp eax, DWORD PTR [rbp-12]
jge .L2
mov eax, DWORD PTR [rbp-4]
cdqe
mov DWORD PTR [rbp-96+rax*4], 1
jmp .L3
.L2:
mov eax, DWORD PTR [rbp-4]
cdqe
mov DWORD PTR [rbp-96+rax*4], 0
.L3:
mov eax, 0
pop rbp
ret
__static_initialization_and_destruction_0(int, int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
cmp DWORD PTR [rbp-4], 1
jne .L7
cmp DWORD PTR [rbp-8], 65535
jne .L7
mov edi, OFFSET FLAT:std::__ioinit
call std::ios_base::Init::Init()
mov edx, OFFSET FLAT:__dso_handle
mov esi, OFFSET FLAT:std::__ioinit
mov edi, OFFSET FLAT:std::ios_base::Init::~Init()
call __cxa_atexit
.L7:
nop
leave
ret
push rbp
mov rbp, rsp
mov esi, 65535
mov edi, 1
call __static_initialization_and_destruction_0(int, int)
pop rbp
ret.
Clarify how cells and molecules are linked to tissuesSolutionA.pdf
Clarify how cells and molecules are linked to tissues
Solution
Answer:
Various molecules together are going to from organelles & finally to form cells and cells
together to form tissues, a complex multicellular component of organs & organs systems in an
organism. These cells are linked to the tissues via cell adhesion molecules, integral membrane
receptors, connexins, selectins & integrins and cadherins via either homophillic homophillic
binding or heterophillic binding. The cells are going to connect within the tissues via Cell-Matrix
Interactions to basal lamina & cell-cell adhesions or gap junctions or focal adhesions as part of
combinatorial diversity
Foe example:
Transitional epithelium is a stratified epithelium mainly existing in urothelium, urinary bladder,
prostrate and intercellular adhesion is essential for cell to cell communication & these are
existing where the epithelial tissues subjecting to traction & pressure. The prominent
intercellular adhesions existing in transitional epithelium are occluding junctions (zonula
occludens, zonula adherens (existing in prostrate), tight junctions, anchoring adhesive junctions
between cells (desmosomes), gap junctions (connexins) between the cells. Some of the junctions
are promoting intercellular adhesion in transitional epithelium..
More from arpitcomputronics (20)
Neutrons cant be detected by the same detectors as alphas, betas, and.pdf
Neutrons cant be detected by the same detectors as alphas, betas, and.pdf
List each hypothesis that is being tested in a twofactor ANOVA.S.pdf
List each hypothesis that is being tested in a twofactor ANOVA.S.pdf
Marla begins walking at 3 mih toward the library.Her friend meets h.pdf
Marla begins walking at 3 mih toward the library.Her friend meets h.pdf
Mrs. S confides in you that she is terrified of her husband. She rep.pdf
Mrs. S confides in you that she is terrified of her husband. She rep.pdf
In September of 2008, the FDIC paid JP Morgan Chase to purchase all .pdf
In September of 2008, the FDIC paid JP Morgan Chase to purchase all .pdf
In cocker spaniels, black coat color (B) is dominant over red (b), an.pdf
In cocker spaniels, black coat color (B) is dominant over red (b), an.pdf
In most healthy people, toxoplasmosis is an inapparent or mild dise.pdf
In most healthy people, toxoplasmosis is an inapparent or mild dise.pdf
I only need help with four methods in the EmployeeManager class the .pdf
I only need help with four methods in the EmployeeManager class the .pdf
Identify and briefly describe a diffusion network that you have expe.pdf
Identify and briefly describe a diffusion network that you have expe.pdf
how do the masses of the earth, oceans, atmosphere, and biosphere co.pdf
how do the masses of the earth, oceans, atmosphere, and biosphere co.pdf
If the mechanism of DNA replication (semi-conservative, conservative.pdf
If the mechanism of DNA replication (semi-conservative, conservative.pdf
EYCONNEC Cell Structures the arrangement of phospholipids in the plas.pdf
EYCONNEC Cell Structures the arrangement of phospholipids in the plas.pdf
For the balance sheet, please categorize the following as short-term.pdf
For the balance sheet, please categorize the following as short-term.pdf
During World War II, the Manhattan Project developed the first nuclea.pdf
During World War II, the Manhattan Project developed the first nuclea.pdf
Deoxy sugars are modified sugars where one or more OH groups are remo.pdf
Deoxy sugars are modified sugars where one or more OH groups are remo.pdf
Determine truth value of the statement. Domain consists of all real .pdf
Determine truth value of the statement. Domain consists of all real .pdf
Describe the niches of at least 3 species of wildlife that might be .pdf
Describe the niches of at least 3 species of wildlife that might be .pdf
Define multicollinearity in the following termsa. In which type o.pdf
Define multicollinearity in the following termsa. In which type o.pdf
Convert the for loop Into MIPS Instructions. Use the sit instruction .pdf
Convert the for loop Into MIPS Instructions. Use the sit instruction .pdf
Clarify how cells and molecules are linked to tissuesSolutionA.pdf
Clarify how cells and molecules are linked to tissuesSolutionA.pdf
Recently uploaded
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
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.
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...Nguyen Thanh Tu Collection
https://app.box.com/s/hqnndn05v4q5a4k4jd597rkdbda0fniiUnit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
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 etcChapter 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.
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is prepared for master's students (MIFB & MIBS) UUM. May it be useful to all.special B.ed 2nd year old paper_20240531.pdf
Instagram:-
https://instagram.com/special_education_needs_01?igshid=YmMyMTA2M2Y=
WhatsApp:-
https://chat.whatsapp.com/JVakNIYlSV94x7bwunO3Dc
YouTube:-
https://youtube.com/@special_education_needs
Teligram :- https://t.me/special_education_needs
Slide Shere :-
https://www.slideshare.net/shabnambano20?utm_campaign=profiletracking&utm_medium=sssite&utm_source=ssslideview
Supporting (UKRI) OA monographs at Salford.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk from the OECD’s Centre for Educational Research and Innovation presents at the Ask an Expert Webinar: How can education support child empowerment?
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
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Event Link:-
https://meetups.mulesoft.com/events/details/mulesoft-mysore-presents-exploring-gemini-ai-and-integration-with-mulesoft/
Agenda
● Java 17 Upgrade Overview
● Why and by when do customers need to upgrade to Java 17?
● Is there any immediate impact to upgrading to Mule Runtime 4.6 and beyond?
● Which MuleSoft products are in scope?
For Upcoming Meetups Join Mysore Meetup Group - https://meetups.mulesoft.com/mysore/
YouTube:- youtube.com/@mulesoftmysore
Mysore WhatsApp group:- https://chat.whatsapp.com/EhqtHtCC75vCAX7gaO842N
Speaker:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Organizers:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Giridhar Meka - https://www.linkedin.com/in/giridharmeka
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Shyam Raj Prasad-
https://www.linkedin.com/in/shyam-raj-prasad/
Model Attribute Check Company Auto Property
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
Recently uploaded (20)
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
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
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Multithreading_in_C++ - std::thread, race condition
Multithreading_in_C++ - std::thread, race condition
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk - How can education support child empowerment.pptx
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
write recursive function that calculates and returns the length of a.pdf
- 1. write recursive function that calculates and returns the length of a linked list Solution // C code to determine length of linked list recursively #include #include // node of linked list struct node { int key; struct node* next; }; // push key to linked list void push(struct node** root, int new_element) { struct node* nodeNew = (struct node*) malloc(sizeof(struct node)); nodeNew->key = new_element; nodeNew->next = (*root); (*root) = nodeNew; } // recursively get length of linked list int lengthLinkedlist(struct node* root) { // base case if (root == NULL) return 0; // recursively call the function return 1 + lengthLinkedlist(root->next); } int main()
- 2. { struct node* root = NULL; push(&root, 11); push(&root, 34); push(&root, 4); push(&root, 23); push(&root, 14); push(&root, 88); push(&root, 56); push(&root, 84); push(&root, 6); /* Check the count function */ printf("Length of Linked list: %d ", lengthLinkedlist(root)); return 0; } /* output: Length of Linked list: 9 */