#includestdio.h#includestring.h#includestdlib.h#define M.pdf
•
0 likes•2 views
#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.
Report
Share
Report
Share
Download to read offline
![#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;](https://image.slidesharecdn.com/includestdio-230409021757-13e08247/85/includestdio-h-includestring-h-includestdlib-h-define-M-pdf-1-320.jpg)
Recommended
write recursive function that calculates and returns the length of a.pdf
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
*/.
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
.
Solution#includestdio.h#includeconio.h#includealloc.h.pdf
Solution
:
#include
#include
#include
//-------------------------------------------------
struct node
{
int data;
struct node *next;
}*start=NULL;
//------------------------------------------------------------
void creat()
{
char ch;
do
{
struct node *new_node,*current;
new_node=(struct node *)malloc(sizeof(struct node));
printf(\"nEnter the data : \");
scanf(\"%d\",&new_node->data);
new_node->next=NULL;
if(start==NULL)
{
start=new_node;
current=new_node;
}
else
{
current->next=new_node;
current=new_node;
}
printf(\"nDo you want to creat another : \");
ch=getche();
}while(ch!=\'n\');
}
//------------------------------------------------------------------
void display()
{
struct node *new_node;
printf(\"The Linked List : n\");
new_node=start;
while(new_node!=NULL)
{
printf(\"%d--->\",new_node->data);
new_node=new_node->next;
}
printf(\"NULL\");
}
//----------------------------------------------------
void main()
{
create();
display();
}
//----------------------------------------------------
Output :
#include
#include
#include
#include
struct node {
int data;
int key;
struct node *next;
struct node *prev;
};
//this link always point to first Link
struct node *head = NULL;
//this link always point to last Link
struct node *last = NULL;
struct node *current = NULL;
//is list empty
bool isEmpty(){
return head == NULL;
}
int length(){
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next){
length++;
}
return length;
}
//display the list in from first to last
void displayForward(){
//start from the beginning
struct node *ptr = head;
//navigate till the end of the list
printf(\"\ [ \");
while(ptr != NULL){
printf(\"(%d,%d) \",ptr->key,ptr->data);
ptr = ptr->next;
}
printf(\" ]\");
}
//display the list from last to first
void displayBackward(){
//start from the last
struct node *ptr = last;
//navigate till the start of the list
printf(\"\ [ \");
while(ptr != NULL){
//print data
printf(\"(%d,%d) \",ptr->key,ptr->data);
//move to next item
ptr = ptr ->prev;
printf(\" \");
}
printf(\" ]\");
}
//insert link at the first location
void insertFirst(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//update first prev link
head->prev = link;
}
//point it to old first link
link->next = head;
//point first to new first link
head = link;
}
//insert link at the last location
void insertLast(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//make link a new last link
last->next = link;
//mark old last node as prev of new link
link->prev = last;
}
//point last to new last node
last = link;
}
//delete first item
struct node* deleteFirst(){
//save reference to first link
struct node *tempLink = head;
//if only one link
if(head->next == .
M 0 1 2 3 4 5 6 7 0.pdf
**** Computer Architecture ****
5 Subtract - 12 from 27 by using 8-bit signed magnitude, one's complement, two's complement
arithmetic, respectively. ( 2 pts 3=6 pts) 6 Add 12 to -27 by using 8-bit signed magnitude, one's
complement, two's complement arithmetic, respectively. ( 2 pts 3=6 pts) 7 Perform the following
multiplications by using Booth's algorithm, assuming 8-bit two's complement integers: (4 pts) 1) 12
x27 8 Multiply the value 64 (expressed by 8-bit signed two's complement representation) by 2. (2
pts) 9 Divide the value -64 (expressed by 8-bit signed two's complement representation) by 4 . ( 2
pts) 10 Express the following binary fraction in normalized floating-point form using the simple
model with excess-15 bias: (2 pts) 1) 34.0625.
Write a simple program in C (which comiles in gcc a unix environment ).docx
Write a simple program in C (which comiles in gcc a unix environment ) implementing a stack using a linked list and a struct holding the linked list, which stores the location of the top and bottom of the stack.
struct node { int val; //integer node value
struct node *next; //pointer to next node };
struct stack { struct node *head; //pointer to first node in stack
struct node *tail; //pointer to top of stack };
Begin by implementing the following stack operations:
void init(struct stack *); //initialize stack members
void push(struct stack *, int); //grow contents to store int
int pop(struct stack *); //shrink contents and return top int
Include for printf/scanf • Include for malloc/free and NULL • Use the -> to access members from a struct pointer
Solution
#include <stdio.h>
#include <stdlib.h>
//structure declared
struct node
{
int val;
struct node *next;
}*top;
//method to pop data from stack
void pop()
{
struct node *temp, *stackVar=top;
if(stackVar==top) //removing data from stack
{
top = top->next;
free(stackVar);
}
else{ //if stack empty
printf(\"\ Empty stack\");
}
}
//adding number to stack
void push(int value)
{
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
temp->val=value;
if (top == NULL) //if stack empty
{
top=temp;
top->next=NULL;
}
else //if stack not empty..just append
{
temp->next=top;
top=temp;
}
}
//prinring stack
void display()
{
struct node *stackVar=top;
if(stackVar!=NULL)
{
printf(\"\ Elements are as:\ \");
while(stackVar!=NULL)
{
printf(\"\\t%d\ \",stackVar->val);
stackVar=stackVar->next;
}
printf(\"\ \");
}
else
printf(\"\ Stack is Empty\");
}
int main(int argc, char *argv[])
{
int choice=0;
top=NULL;
//displaying menu
printf(\" 1. Push\");
printf(\" 2. Pop\");
printf(\" 3. Display\");
printf(\" 4. Exit\ \");
while(1)
{
//reading option
scanf(\"%d\",&choice);
switch(choice)
{
//adding number to stack
case 1:
{
int val;
printf(\"\ Enter number to push: \");
scanf(\"%d\",&val);
push(val);
display();
break;
}
//removing number from stack
case 2:
{
pop();
display();
break;
}
//displaying stack
case 3:
{
display();
break;
}
//exit from app
case 4:
{
printf(\"\ Thank you\");
break;
}
default:
{
printf(\"\ Enter correct choice: \");
}
}
}
}
.
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.
Recommended
write recursive function that calculates and returns the length of a.pdf
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
*/.
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
.
Solution#includestdio.h#includeconio.h#includealloc.h.pdf
Solution
:
#include
#include
#include
//-------------------------------------------------
struct node
{
int data;
struct node *next;
}*start=NULL;
//------------------------------------------------------------
void creat()
{
char ch;
do
{
struct node *new_node,*current;
new_node=(struct node *)malloc(sizeof(struct node));
printf(\"nEnter the data : \");
scanf(\"%d\",&new_node->data);
new_node->next=NULL;
if(start==NULL)
{
start=new_node;
current=new_node;
}
else
{
current->next=new_node;
current=new_node;
}
printf(\"nDo you want to creat another : \");
ch=getche();
}while(ch!=\'n\');
}
//------------------------------------------------------------------
void display()
{
struct node *new_node;
printf(\"The Linked List : n\");
new_node=start;
while(new_node!=NULL)
{
printf(\"%d--->\",new_node->data);
new_node=new_node->next;
}
printf(\"NULL\");
}
//----------------------------------------------------
void main()
{
create();
display();
}
//----------------------------------------------------
Output :
#include
#include
#include
#include
struct node {
int data;
int key;
struct node *next;
struct node *prev;
};
//this link always point to first Link
struct node *head = NULL;
//this link always point to last Link
struct node *last = NULL;
struct node *current = NULL;
//is list empty
bool isEmpty(){
return head == NULL;
}
int length(){
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next){
length++;
}
return length;
}
//display the list in from first to last
void displayForward(){
//start from the beginning
struct node *ptr = head;
//navigate till the end of the list
printf(\"\ [ \");
while(ptr != NULL){
printf(\"(%d,%d) \",ptr->key,ptr->data);
ptr = ptr->next;
}
printf(\" ]\");
}
//display the list from last to first
void displayBackward(){
//start from the last
struct node *ptr = last;
//navigate till the start of the list
printf(\"\ [ \");
while(ptr != NULL){
//print data
printf(\"(%d,%d) \",ptr->key,ptr->data);
//move to next item
ptr = ptr ->prev;
printf(\" \");
}
printf(\" ]\");
}
//insert link at the first location
void insertFirst(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//update first prev link
head->prev = link;
}
//point it to old first link
link->next = head;
//point first to new first link
head = link;
}
//insert link at the last location
void insertLast(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//make link a new last link
last->next = link;
//mark old last node as prev of new link
link->prev = last;
}
//point last to new last node
last = link;
}
//delete first item
struct node* deleteFirst(){
//save reference to first link
struct node *tempLink = head;
//if only one link
if(head->next == .
M 0 1 2 3 4 5 6 7 0.pdf
**** Computer Architecture ****
5 Subtract - 12 from 27 by using 8-bit signed magnitude, one's complement, two's complement
arithmetic, respectively. ( 2 pts 3=6 pts) 6 Add 12 to -27 by using 8-bit signed magnitude, one's
complement, two's complement arithmetic, respectively. ( 2 pts 3=6 pts) 7 Perform the following
multiplications by using Booth's algorithm, assuming 8-bit two's complement integers: (4 pts) 1) 12
x27 8 Multiply the value 64 (expressed by 8-bit signed two's complement representation) by 2. (2
pts) 9 Divide the value -64 (expressed by 8-bit signed two's complement representation) by 4 . ( 2
pts) 10 Express the following binary fraction in normalized floating-point form using the simple
model with excess-15 bias: (2 pts) 1) 34.0625.
Write a simple program in C (which comiles in gcc a unix environment ).docx
Write a simple program in C (which comiles in gcc a unix environment ) implementing a stack using a linked list and a struct holding the linked list, which stores the location of the top and bottom of the stack.
struct node { int val; //integer node value
struct node *next; //pointer to next node };
struct stack { struct node *head; //pointer to first node in stack
struct node *tail; //pointer to top of stack };
Begin by implementing the following stack operations:
void init(struct stack *); //initialize stack members
void push(struct stack *, int); //grow contents to store int
int pop(struct stack *); //shrink contents and return top int
Include for printf/scanf • Include for malloc/free and NULL • Use the -> to access members from a struct pointer
Solution
#include <stdio.h>
#include <stdlib.h>
//structure declared
struct node
{
int val;
struct node *next;
}*top;
//method to pop data from stack
void pop()
{
struct node *temp, *stackVar=top;
if(stackVar==top) //removing data from stack
{
top = top->next;
free(stackVar);
}
else{ //if stack empty
printf(\"\ Empty stack\");
}
}
//adding number to stack
void push(int value)
{
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
temp->val=value;
if (top == NULL) //if stack empty
{
top=temp;
top->next=NULL;
}
else //if stack not empty..just append
{
temp->next=top;
top=temp;
}
}
//prinring stack
void display()
{
struct node *stackVar=top;
if(stackVar!=NULL)
{
printf(\"\ Elements are as:\ \");
while(stackVar!=NULL)
{
printf(\"\\t%d\ \",stackVar->val);
stackVar=stackVar->next;
}
printf(\"\ \");
}
else
printf(\"\ Stack is Empty\");
}
int main(int argc, char *argv[])
{
int choice=0;
top=NULL;
//displaying menu
printf(\" 1. Push\");
printf(\" 2. Pop\");
printf(\" 3. Display\");
printf(\" 4. Exit\ \");
while(1)
{
//reading option
scanf(\"%d\",&choice);
switch(choice)
{
//adding number to stack
case 1:
{
int val;
printf(\"\ Enter number to push: \");
scanf(\"%d\",&val);
push(val);
display();
break;
}
//removing number from stack
case 2:
{
pop();
display();
break;
}
//displaying stack
case 3:
{
display();
break;
}
//exit from app
case 4:
{
printf(\"\ Thank you\");
break;
}
default:
{
printf(\"\ Enter correct choice: \");
}
}
}
}
.
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.
Easy Understanding of Structure Union Typedef Enum in C Language.pdf
Easy Understanding of Structure Union Typedef Enum in C Language
Create a JAVA program that performs file IO and database interaction.pdf
Create a JAVA program that performs file IO and database interaction via SQL. The program
needs to read data from the provided file: \"Project.csv\" and insert the data into a database. Then
the program needs to create a report from the database sorted by price descending. The report
should be in the format demonstrated below.
id (primary key - generated by the database)
cpuname
performance
price
Project.csv contents:CPU NamePerformancePrice (USD)Intel Core i7-3770K @
3.50GHz9,556$560.50Intel Core i7-3770 @ 3.40GHz9,327$335.55Intel Core i7-3820 @
3.60GHz8,990$404.38AMD FX-8350 Eight-Core8,940$149.99Intel Core i7-2600K @
3.40GHz8,501$379.97Intel Core i7-2600 @ 3.40GHz8,242$214.99Intel Core i7-4720HQ @
2.60GHz8,046NAAMD FX-8320 Eight-Core8,008$145.99Intel Core i7-6700HQ @
2.60GHz7,997$1509Intel Core i7-4710HQ @ 2.50GHz7,826NAIntel Core i5-6600K @
3.50GHz7,762$239.99Intel Core i7-4700HQ @ 2.40GHz7,754$383.00Intel Core i7-4700MQ
@ 2.40GHz7,736$467.40Intel Core i5-4690K @ 3.50GHz7,690$239.99AMD FX-8150 Eight-
Core7,619$165.99Intel Core i7-3630QM @ 2.40GHz7,604$304.49Intel Core i5-4670K @
3.40GHz7,598$249.99Intel Core i5-4690 @ 3.50GHz7,542$224.99Intel Core i7-3610QM @
2.30GHz7,460$399.99Intel Core i5-4670 @ 3.40GHz7,342$226.99Intel Core i5-4590 @
3.30GHz7,174$199.99Intel Core i7-4702MQ @ 2.20GHz7,146NAIntel Core i5-3570K @
3.40GHz7,130$477.23
Solution
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
public class Main
{
/**
* This the main function that runs at the start
* param args - input arguments from the command line
*/
static public void main(String[] args)
{
CPUList cpuList = new CPUList(); //The CPUList used to retrieve data from the
fiile and store in the db
CPUList cpuListRetrieved = new CPUList(); //The CPUList used to retrieve data from the
database
CpuDb cpuDb = new CpuDb(); //The database object used to move data to and
from the CPU Lists
try
{
//Read in the file and store each line into the CPU objects in a list
Files.lines(Paths.get(\"Project04Data.csv\"))
.map(line -> line.split(\"\ \ \")) // Stream
.flatMap(Arrays::stream) // Stream
.forEach(line -> cpuList.AddCpu(line));
//Clear the list table for the new listing
cpuDb.Clear();
//Insert the Cpu List into the database
cpuDb.SetCpuList(cpuList);
//Retrieve the Cpu List into a different CPU List object from the database
cpuDb.GetCpuList(cpuListRetrieved);
//Show the report from the new list that was retrieved from the database
cpuListRetrieved.ShowReport();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
CPUList.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class CPUList
{
ArrayList theList = new ArrayList<>();
/**
* Default constructor for the CPU
*/
public void CPUList()
{
}
/**
* param strInputLine Input line to be used in creating the CPU object
*/
public void AddCpu(String strInputLine)
{
theList.add(new CPU(strInputLine));
}
/**
* param tempCPU - A CPU object to.
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.
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned integers in postfix notation
and builds the arithmetic expression tree that represents that expression. From that tree, the
corresponding fully parenthesized infix expression should be displayed and a file should be
generated that contains the three address format instructions. This topic is discussed in the week
4 reading in module 2, section II-B. The main class should create the GUI shown below:
Pressing the Construct Tree button should cause the tree to be constructed and using that tree, the
corresponding infix expression should be displayed and the three address instruction file should
be generated. The postfix expression input should not be required to have spaces between every
token. Note in the above example that 9+- are not separated by spaces. The above example
should produce the following output file containing the three address instructions:
Add R0 5 9
Sub R1 3
R0 Mul R2 2 3
Div R3 R1 R2
Inheritance should be used to define the arithmetic expression tree. At a minimum, it should
involve three classes: an abstract class for the tree nodes and two derived classes, one for
operand nodes and another for operator nodes. Other classes should be included as needed to
accomplish good object-oriented design. All instance data must be declared as private.
You may assume that the expression is syntactically correct with regard to the order of operators
and operands, but you should check for invalid tokens, such as characters that are not valid
operators or operands such as 2a, which are not valid integers. If an invalid token is detected a
RuntimeException should be thrown and caught by the main class and an appropriate error
message should be displayed. Three Adddress Generator Enter Postfix Expression 359 2 3
Construct Tree Infix Expression ((3-(5 9))/ (2* 3
Solution
#include
#include
#include
#include
#include
struct TREE //Structure to represent a tree
{
char data;
struct TREE *right,*left,*root;
};
typedef TREE tree; /* Stack Using Linked List */
struct Stack //Structure to represent Stack
{
struct TREE *data;
struct Stack *next,*head,*top; //Pointers to next node,head and top
};
typedef struct Stack node;
node *Nw; //Global Variable to represent node
void initialize(node *&n)
{
n = new node;
n -> next = n -> head = n -> top = NULL;
}
void create(node *n)
{
Nw = new node; //Create a new node
Nw -> next = NULL; //Initialize next pointer field
if(n -> head == NULL) //if first node
{
n -> head = Nw; //Initialize head
n -> top = Nw; //Update top
}
}
void push(node *n,tree *ITEM)
{
node *temp = n -> head;
if(n -> head == NULL) //if First Item is Pushed to Stack
{
create(n); //Create a Node
n -> head -> data = ITEM; //Insert Item to head of List
n -> head = Nw;
return; //Exit from Function
}
create(n); //Create a new Node
Nw -> data = ITEM; //Insert Item
while(temp -> next != NULL)
temp = temp -> next; //Go to Last Node
temp -> next = Nw; //Point New node
n -> top = Nw; //Upda.
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.
Use the code below from the previous assignment that we need to exte.pdf
Use the code below from the previous assignment that we need to extend just follow the
instructions above.
***Make sure after you are done to show the output of your results***
main.cpp
#include
#include "Contact.h"
int main()
{
// create Contact object using parameterized constructor
Contact c1("Barbara", "Liskov", "Huberman", "404 Ridgeway Dr", "NC", "27403", "336-274-
3344");
// show contact details
c1.showContact();
cout << endl;
// create Contact object using default constructor
Contact c2;
// test the overloaded input and output operators
cin >> c2;
cout << endl;
cout << c2;
return 0;
}
Address.h
#ifndef ADDRESS_H
#define ADDRESS_H
#include
using namespace std;
// create a class named Address
class Address
{
private:
// private instance variables
string streetAddress, state, zip;
public:
// default constructor
Address()
{
// initialize instance variables with empty strings
streetAddress = "";
state = "";
zip = "";
}
// parameterized constructor
Address(string streetAddress, string state, string zip)
{
// initialize instance variables to given parameters
this->streetAddress = streetAddress;
this->state = state;
this->zip = zip;
}
// copy constructor
Address(const Address &a)
{
streetAddress = a.streetAddress;
state = a.state;
zip = a.zip;
}
// setters for all instance variables
void setStreetAddress(string streetAddress) { this->streetAddress = streetAddress; }
void setState(string state) { this->state = state; }
void setZip(string zip) { this->zip = zip; }
// getters for all instance variables
string getStreetAddress() { return streetAddress; }
string getState() { return state; }
string getZip() { return zip; }
// method to display the address
void showAddress()
{
cout << streetAddress << "\n"
<< state << " " << zip << endl;
}
// declare the overloaded input and output operators
friend ostream &operator<<(ostream &out, const Address &a);
friend istream &operator>>(istream &in, Address &a);
};
// define the overloaded output operator
ostream &operator<<(ostream &out, const Address &a)
{
out << a.streetAddress << "\n"
<< a.state << " " << a.zip << endl;
return out;
}
// define the overloaded input operator
istream &operator>>(istream &in, Address &a)
{
cout << "Enter street address: ";
getline(in, a.streetAddress);
cout << "Enter state: ";
getline(in, a.state);
cout << "Enter zip: ";
getline(in, a.zip);
return in;
}
#endif
Contact.h
#ifndef CONTACT_H
#define CONTACT_H
#include
#include "Name.h"
#include "Address.h"
using namespace std;
// create a class named Contact
class Contact
{
private:
// private instance variables
Name name;
Address address;
string phone;
public:
// default constructor
Contact()
{
// initialize phone with empty string
phone = "";
}
// parameterized constructor
Contact(string first_name, string last_name, string middle_name, string streetAddress, string
state, string zip, string phone)
{
// initialize name and address to given strings
setName(first_name, last_name, middle_name);
setAddress(streetAddress, state, zip).
include ltfunctionalgt include ltiteratorgt inclu.pdf
#include <functional>
#include <iterator>
#include <limits>
#include <memory>
template<typename T>
class List
{
private:
struct Node;
struct Iterator;
struct ConstIterator;
public:
using value_type = T;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using reference = value_type&;
using const_reference = value_type const&;
using pointer = value_type*;
using const_pointer = value_type const*;
using iterator = Iterator;
using const_iterator = ConstIterator;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
private:
struct Node
{
Node () : data ()
{
}
Node (T const& v) : data (v)
{
}
Node (T const& v, Node* n, Node* p) : data (v), next (n), prev (p)
{
}
Node (T&& v) : data (std::move (v))
{
}
Node (T&& v, Node* n, Node* p) : data (std::move (v)), next (n), prev (p)
{
}
// this is start of range to remove
// end is inclusive end of range to remove
static void
unhook (Node* begin, Node* end)
{
begin -> prev -> next = end -> next;
end -> next -> prev = begin -> prev;
}
// insert [first,last] before this
void
hook (Node* first, Node* last)
{
first -> prev = prev;
last -> next = this;
prev -> next = first;
prev = last;
}
// insert first before this
void
hook (Node* first)
{
hook (first, first);
}
void
unhook ()
{
Node::unhook (this, this);
}
T data;
Node* next{nullptr};
Node* prev{nullptr};
};
struct Iterator
{
using value_type = List::value_type;
using pointer = List::pointer;
using reference = List::reference;
using difference_type = List::difference_type;
using iterator_category = std::bidirectional_iterator_tag;
public:
Iterator () noexcept = default;
Iterator (Iterator const&) noexcept = default;
Iterator (Iterator&&) noexcept = default;
~Iterator () = default;
Iterator&
operator= (Iterator const&) noexcept = default;
Iterator&
operator= (Iterator&&) noexcept = default;
Iterator (Node const* n) : m_nodePtr (const_cast<Node*> (n))
{
}
reference operator* () const
{
return m_nodePtr->data;
}
pointer operator-> () const
{
return &(m_nodePtr->data);
}
// advances to the "next" pointer, returns reference to self
Iterator&
operator++ ()
{
m_nodePtr = m_nodePtr -> next;
return *this;
}
// advances to the "next" pointer, returns copy of self prior to advancement
Iterator
operator++ (int)
{
iterator temp(*this);
++(*this);
return temp;
}
// advances to the "prev" pointer, returns reference to self
Iterator&
operator-- ()
{
m_nodePtr = m_nodePtr -> prev;
return *this;
}
// advances to the "prev" pointer, returns copy of self prior to advancement
Iterator
operator-- (int)
{
iterator temp(*this);
--(*this);
return temp;
}
// compares the underlying pointers for equality
friend bool
operator== (Iterator const& i, Iterator const& j)
{
return i.m_nodePtr == j.m_nodePtr;
}
friend bool
operator!= (Iterator const& i, Iterator const& j)
{
return !(i == j);
}
private:
Node* m_nodePtr{nullptr};
friend class List;
};
struct ConstIterator
{
using value_type = List::val.
Implement of c & its coding programming by sarmad baloch
Implement of c & its coding programming by sarmad baloch
So here is the code from the previous assignment that we need to ext.pdf
So here is the code from the previous assignment that we need to extend just follow the
instructions above.
main.cpp
#include
#include "Contact.h"
int main()
{
// create Contact object using parameterized constructor
Contact c1("Barbara", "Liskov", "Huberman", "404 Ridgeway Dr", "NC", "27403", "336-274-
3344");
// show contact details
c1.showContact();
cout << endl;
// create Contact object using default constructor
Contact c2;
// test the overloaded input and output operators
cin >> c2;
cout << endl;
cout << c2;
return 0;
}
Address.h
#ifndef ADDRESS_H
#define ADDRESS_H
#include
using namespace std;
// create a class named Address
class Address
{
private:
// private instance variables
string streetAddress, state, zip;
public:
// default constructor
Address()
{
// initialize instance variables with empty strings
streetAddress = "";
state = "";
zip = "";
}
// parameterized constructor
Address(string streetAddress, string state, string zip)
{
// initialize instance variables to given parameters
this->streetAddress = streetAddress;
this->state = state;
this->zip = zip;
}
// copy constructor
Address(const Address &a)
{
streetAddress = a.streetAddress;
state = a.state;
zip = a.zip;
}
// setters for all instance variables
void setStreetAddress(string streetAddress) { this->streetAddress = streetAddress; }
void setState(string state) { this->state = state; }
void setZip(string zip) { this->zip = zip; }
// getters for all instance variables
string getStreetAddress() { return streetAddress; }
string getState() { return state; }
string getZip() { return zip; }
// method to display the address
void showAddress()
{
cout << streetAddress << "\n"
<< state << " " << zip << endl;
}
// declare the overloaded input and output operators
friend ostream &operator<<(ostream &out, const Address &a);
friend istream &operator>>(istream &in, Address &a);
};
// define the overloaded output operator
ostream &operator<<(ostream &out, const Address &a)
{
out << a.streetAddress << "\n"
<< a.state << " " << a.zip << endl;
return out;
}
// define the overloaded input operator
istream &operator>>(istream &in, Address &a)
{
cout << "Enter street address: ";
getline(in, a.streetAddress);
cout << "Enter state: ";
getline(in, a.state);
cout << "Enter zip: ";
getline(in, a.zip);
return in;
}
#endif
Contact.h
#ifndef CONTACT_H
#define CONTACT_H
#include
#include "Name.h"
#include "Address.h"
using namespace std;
// create a class named Contact
class Contact
{
private:
// private instance variables
Name name;
Address address;
string phone;
public:
// default constructor
Contact()
{
// initialize phone with empty string
phone = "";
}
// parameterized constructor
Contact(string first_name, string last_name, string middle_name, string streetAddress, string
state, string zip, string phone)
{
// initialize name and address to given strings
setName(first_name, last_name, middle_name);
setAddress(streetAddress, state, zip);
// initialize phone to the given parameter
this->phone = phone;
}
/.
in c languageTo determine the maximum string length, we need to .pdf
in c language
To determine the maximum string length, we need to create a new callback function that utilizes
an alternative user data structure. This callback function should adhere to the same format as
demonstrated in the example.
The data provided to our callback consists of:
A node containing the node->data pointer, which will store our string.
A userdata argument, represented as (void *), capable of holding any desired content. We
possess complete control over the content at this pointer location, as it will be whatever value we
have passed. Consequently, we can:
Establish a structure to store any pertinent values we require.
Transmit the address of this structure into the function.
use this code and just add your code where it says TO DO
#include
#include
#include
#include
#include "LLGeneric.h"
/** define the maximum length of a line that we can read */
#defineLINE_BUFFER_SIZE1024
/**
* We can use this as our "user data" to help us calculate the maximum
* length string
*
* Add anything else to this structure that you wish
*/
struct maxData {
size_t maxLenSoFar;
char *maxStringSoFar;
};
/**
* our "user function" or "callback" for printing.
*
* We know what "void *userdata" is going to be because it is
* simply what we pass in at the call below, so it is safe to
* cast back to a FILE * as that is what we passed it.
*
* This is called a "callback" as it "call back into" our own
* code from within a generic routine.
*/
int myFindLongestStringNode(GenericListNode *node, int index, void *userdata)
{
/**
* Add more code here. You will need to:
* - convert the GenericListNode payload in the field "data" to your
* known (char *) type
* - conver the (void *) userdata into your known (struct maxData *)
* type
* - use the fact that you can examine and store the values provided
* through the userdata to see what has been calculated by earlier
* calls to this function and update based on what you see here,
* in order to determine what the longest string is in the whole
* set of nodes.
*/
return 1;
}
int
doListActivities(GenericListNode *list)
{
/** create an instance of our structure for use as the user data */
struct maxData maxDataWorkingStruct;
int nProcessed = 0;
/** initialize our structure -- if you added fields, set them up here */
maxDataWorkingStruct.maxLenSoFar = 0;
maxDataWorkingStruct.maxStringSoFar = NULL;
/**
* TO DO: Iterate using the callback, which should calculate what
* the longest string in the list is
*/
nProcessed = lstPerformIterativeAction(
list, /* pointer to the first list node */
myFindLongestStringNode, /* pointer to our function */
(void *) &maxDataWorkingStruct);
/** print out the result */
printf("The longest string has %ld characters\n",
maxDataWorkingStruct.maxLenSoFar);
printf("The longest string is: %s\n",
maxDataWorkingStruct.maxStringSoFar);
return nProcessed;
}
/**
**Tools provided below here you won't need to edit -- they
**simply process the command line, and load and free the
**generic linked list and the st.
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.
array, function, pointer, pattern matching
As a part of the course material of CSC 391- Data structure and algorithm. Review of previous concept of array, pointer and functions.
Frequency .java Word frequency counter package frequ.pdf
Frequency .java
/**
* Word frequency counter
*/
package frequency;
import java.util.Iterator;
/**
*
* @author UMD CS
*/
public class Frequency implements Iterable{
private Node first;
private int N;
Frequency(){
N = 0;
first = null;
}
@Override
public Iterator iterator() {
return new ListIterator();
}
/**
*
* List iterator
*
*/
private class ListIterator implements Iterator{
private Node current;
private int index ;
ListIterator(){
current = first;
index = 0;
}
@Override
public boolean hasNext() {
return current != null;
}
public String next() {
if(!hasNext()){
return null;
}
String word = current.key;
int count = current.count;
String r = \"(\"+word + \",\" + Integer.toString(count)+\")\";
current = current.next;
return r;
}
@Override
public void remove() {
}
}
/**
*
* Node class
*
*/
private class Node {
private String key;
private int count;
private Node next;
Node(String item){
key = item;
count = 1;
next = null;
}
@Override
public String toString(){
return \"(\"+key +\",\"+count+\")\";
}
}
/*
* Inserts a word into the linked list. If the word exists, increment the
* count by q.
*/
public void insert(String word){
if(word.equals(\"\")){
return;
}
//TODO
/*
* implement here
*/
}
/**
*
* @param str input string
* This method splits a string into words and pass the words to insert method
*
*/
public void insertWords(String str){
String delims = \"[ .,?!\'\\\"()}{;/<>&=#-:\\\\ _]+\";
String[] words = str.split(delims);
for(String s: words){
s = s.toLowerCase();
insert(s);
}
}
/**
* prints the word frequency list
*/
public void print(){
Node c = first;
while(c != null){
System.out.print(\"(\"+c.key + \",\" + c.count+\")\");
c = c.next;
}
System.out.print(\"\ \");
}
}
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
WordFrequency.java
package frequency;
import utils.In;
import utils.Stopwatch;
/**
*
* @author UMD CS
*/
public class WordFrequency {
/**
* @param input source
* @param
* This method receives input resource and return the word frequency string
* DO NOT CHANGE THIS METHOD.
*/
public static String freq(String inputSource, int maxLines){
In in;
// Frequency class can only count the frequency of strings. DO NOT CHANGE THIS.
Frequency freq = new Frequency();
int MAX = 100;
String inputSourceName = inputSource;
try {
in = new In(inputSourceName);
while (!in.isEmpty()) {
String s = in.readLine();
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
StringBuilder strFrequency = new StringBuilder();
int cnt = 0;
for(String s: freq){
strFrequency.append(s);
strFrequency.append(\",\");
cnt++;
if(cnt >= maxLines){break;}
}
return strFrequency.toString();
}
/**
*
*/
public static void main(String[] args) {
In in;
Frequency freq = new Frequency();
int MAX = 100;
// String inputSourceName =
\"http://www.cs.umd.edu/class/summer2015/cmsc132/projects/P3_WordFrequency/test1.html\";
String .
mainpublic class AssignmentThree { public static void ma.pdf
// main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
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);.
H2SO4 may act as 1) an acidexample 2NaOH + H2SO4 - Na2SO4 +.pdf
to minimise the length, term with \'m\' should be reduced so first to absolute values
must be opened with negative sign S2 = -4m+1 - 5m+6 + 10m-3 S2 = m+4
Solution
to minimise the length, term with \'m\' should be reduced so first to absolute values
must be opened with negative sign S2 = -4m+1 - 5m+6 + 10m-3 S2 = m+4.
Computer graphics are pictures and movies produced use computers fre.pdf
no. of sand grains in 1 truck = 10/0.1 x 10 ^-6=10^8 sand grains total time taken=
(10 X 6.02x10^23 x 10 )/10^8= 6.02 x 10^17 min= 6.872 x 10^ 13 years
Solution
no. of sand grains in 1 truck = 10/0.1 x 10 ^-6=10^8 sand grains total time taken=
(10 X 6.02x10^23 x 10 )/10^8= 6.02 x 10^17 min= 6.872 x 10^ 13 years.
More Related Content
Similar to #includestdio.h#includestring.h#includestdlib.h#define M.pdf
Easy Understanding of Structure Union Typedef Enum in C Language.pdf
Easy Understanding of Structure Union Typedef Enum in C Language
Create a JAVA program that performs file IO and database interaction.pdf
Create a JAVA program that performs file IO and database interaction via SQL. The program
needs to read data from the provided file: \"Project.csv\" and insert the data into a database. Then
the program needs to create a report from the database sorted by price descending. The report
should be in the format demonstrated below.
id (primary key - generated by the database)
cpuname
performance
price
Project.csv contents:CPU NamePerformancePrice (USD)Intel Core i7-3770K @
3.50GHz9,556$560.50Intel Core i7-3770 @ 3.40GHz9,327$335.55Intel Core i7-3820 @
3.60GHz8,990$404.38AMD FX-8350 Eight-Core8,940$149.99Intel Core i7-2600K @
3.40GHz8,501$379.97Intel Core i7-2600 @ 3.40GHz8,242$214.99Intel Core i7-4720HQ @
2.60GHz8,046NAAMD FX-8320 Eight-Core8,008$145.99Intel Core i7-6700HQ @
2.60GHz7,997$1509Intel Core i7-4710HQ @ 2.50GHz7,826NAIntel Core i5-6600K @
3.50GHz7,762$239.99Intel Core i7-4700HQ @ 2.40GHz7,754$383.00Intel Core i7-4700MQ
@ 2.40GHz7,736$467.40Intel Core i5-4690K @ 3.50GHz7,690$239.99AMD FX-8150 Eight-
Core7,619$165.99Intel Core i7-3630QM @ 2.40GHz7,604$304.49Intel Core i5-4670K @
3.40GHz7,598$249.99Intel Core i5-4690 @ 3.50GHz7,542$224.99Intel Core i7-3610QM @
2.30GHz7,460$399.99Intel Core i5-4670 @ 3.40GHz7,342$226.99Intel Core i5-4590 @
3.30GHz7,174$199.99Intel Core i7-4702MQ @ 2.20GHz7,146NAIntel Core i5-3570K @
3.40GHz7,130$477.23
Solution
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
public class Main
{
/**
* This the main function that runs at the start
* param args - input arguments from the command line
*/
static public void main(String[] args)
{
CPUList cpuList = new CPUList(); //The CPUList used to retrieve data from the
fiile and store in the db
CPUList cpuListRetrieved = new CPUList(); //The CPUList used to retrieve data from the
database
CpuDb cpuDb = new CpuDb(); //The database object used to move data to and
from the CPU Lists
try
{
//Read in the file and store each line into the CPU objects in a list
Files.lines(Paths.get(\"Project04Data.csv\"))
.map(line -> line.split(\"\ \ \")) // Stream
.flatMap(Arrays::stream) // Stream
.forEach(line -> cpuList.AddCpu(line));
//Clear the list table for the new listing
cpuDb.Clear();
//Insert the Cpu List into the database
cpuDb.SetCpuList(cpuList);
//Retrieve the Cpu List into a different CPU List object from the database
cpuDb.GetCpuList(cpuListRetrieved);
//Show the report from the new list that was retrieved from the database
cpuListRetrieved.ShowReport();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
CPUList.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class CPUList
{
ArrayList theList = new ArrayList<>();
/**
* Default constructor for the CPU
*/
public void CPUList()
{
}
/**
* param strInputLine Input line to be used in creating the CPU object
*/
public void AddCpu(String strInputLine)
{
theList.add(new CPU(strInputLine));
}
/**
* param tempCPU - A CPU object to.
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.
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned integers in postfix notation
and builds the arithmetic expression tree that represents that expression. From that tree, the
corresponding fully parenthesized infix expression should be displayed and a file should be
generated that contains the three address format instructions. This topic is discussed in the week
4 reading in module 2, section II-B. The main class should create the GUI shown below:
Pressing the Construct Tree button should cause the tree to be constructed and using that tree, the
corresponding infix expression should be displayed and the three address instruction file should
be generated. The postfix expression input should not be required to have spaces between every
token. Note in the above example that 9+- are not separated by spaces. The above example
should produce the following output file containing the three address instructions:
Add R0 5 9
Sub R1 3
R0 Mul R2 2 3
Div R3 R1 R2
Inheritance should be used to define the arithmetic expression tree. At a minimum, it should
involve three classes: an abstract class for the tree nodes and two derived classes, one for
operand nodes and another for operator nodes. Other classes should be included as needed to
accomplish good object-oriented design. All instance data must be declared as private.
You may assume that the expression is syntactically correct with regard to the order of operators
and operands, but you should check for invalid tokens, such as characters that are not valid
operators or operands such as 2a, which are not valid integers. If an invalid token is detected a
RuntimeException should be thrown and caught by the main class and an appropriate error
message should be displayed. Three Adddress Generator Enter Postfix Expression 359 2 3
Construct Tree Infix Expression ((3-(5 9))/ (2* 3
Solution
#include
#include
#include
#include
#include
struct TREE //Structure to represent a tree
{
char data;
struct TREE *right,*left,*root;
};
typedef TREE tree; /* Stack Using Linked List */
struct Stack //Structure to represent Stack
{
struct TREE *data;
struct Stack *next,*head,*top; //Pointers to next node,head and top
};
typedef struct Stack node;
node *Nw; //Global Variable to represent node
void initialize(node *&n)
{
n = new node;
n -> next = n -> head = n -> top = NULL;
}
void create(node *n)
{
Nw = new node; //Create a new node
Nw -> next = NULL; //Initialize next pointer field
if(n -> head == NULL) //if first node
{
n -> head = Nw; //Initialize head
n -> top = Nw; //Update top
}
}
void push(node *n,tree *ITEM)
{
node *temp = n -> head;
if(n -> head == NULL) //if First Item is Pushed to Stack
{
create(n); //Create a Node
n -> head -> data = ITEM; //Insert Item to head of List
n -> head = Nw;
return; //Exit from Function
}
create(n); //Create a new Node
Nw -> data = ITEM; //Insert Item
while(temp -> next != NULL)
temp = temp -> next; //Go to Last Node
temp -> next = Nw; //Point New node
n -> top = Nw; //Upda.
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.
Use the code below from the previous assignment that we need to exte.pdf
Use the code below from the previous assignment that we need to extend just follow the
instructions above.
***Make sure after you are done to show the output of your results***
main.cpp
#include
#include "Contact.h"
int main()
{
// create Contact object using parameterized constructor
Contact c1("Barbara", "Liskov", "Huberman", "404 Ridgeway Dr", "NC", "27403", "336-274-
3344");
// show contact details
c1.showContact();
cout << endl;
// create Contact object using default constructor
Contact c2;
// test the overloaded input and output operators
cin >> c2;
cout << endl;
cout << c2;
return 0;
}
Address.h
#ifndef ADDRESS_H
#define ADDRESS_H
#include
using namespace std;
// create a class named Address
class Address
{
private:
// private instance variables
string streetAddress, state, zip;
public:
// default constructor
Address()
{
// initialize instance variables with empty strings
streetAddress = "";
state = "";
zip = "";
}
// parameterized constructor
Address(string streetAddress, string state, string zip)
{
// initialize instance variables to given parameters
this->streetAddress = streetAddress;
this->state = state;
this->zip = zip;
}
// copy constructor
Address(const Address &a)
{
streetAddress = a.streetAddress;
state = a.state;
zip = a.zip;
}
// setters for all instance variables
void setStreetAddress(string streetAddress) { this->streetAddress = streetAddress; }
void setState(string state) { this->state = state; }
void setZip(string zip) { this->zip = zip; }
// getters for all instance variables
string getStreetAddress() { return streetAddress; }
string getState() { return state; }
string getZip() { return zip; }
// method to display the address
void showAddress()
{
cout << streetAddress << "\n"
<< state << " " << zip << endl;
}
// declare the overloaded input and output operators
friend ostream &operator<<(ostream &out, const Address &a);
friend istream &operator>>(istream &in, Address &a);
};
// define the overloaded output operator
ostream &operator<<(ostream &out, const Address &a)
{
out << a.streetAddress << "\n"
<< a.state << " " << a.zip << endl;
return out;
}
// define the overloaded input operator
istream &operator>>(istream &in, Address &a)
{
cout << "Enter street address: ";
getline(in, a.streetAddress);
cout << "Enter state: ";
getline(in, a.state);
cout << "Enter zip: ";
getline(in, a.zip);
return in;
}
#endif
Contact.h
#ifndef CONTACT_H
#define CONTACT_H
#include
#include "Name.h"
#include "Address.h"
using namespace std;
// create a class named Contact
class Contact
{
private:
// private instance variables
Name name;
Address address;
string phone;
public:
// default constructor
Contact()
{
// initialize phone with empty string
phone = "";
}
// parameterized constructor
Contact(string first_name, string last_name, string middle_name, string streetAddress, string
state, string zip, string phone)
{
// initialize name and address to given strings
setName(first_name, last_name, middle_name);
setAddress(streetAddress, state, zip).
include ltfunctionalgt include ltiteratorgt inclu.pdf
#include <functional>
#include <iterator>
#include <limits>
#include <memory>
template<typename T>
class List
{
private:
struct Node;
struct Iterator;
struct ConstIterator;
public:
using value_type = T;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using reference = value_type&;
using const_reference = value_type const&;
using pointer = value_type*;
using const_pointer = value_type const*;
using iterator = Iterator;
using const_iterator = ConstIterator;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
private:
struct Node
{
Node () : data ()
{
}
Node (T const& v) : data (v)
{
}
Node (T const& v, Node* n, Node* p) : data (v), next (n), prev (p)
{
}
Node (T&& v) : data (std::move (v))
{
}
Node (T&& v, Node* n, Node* p) : data (std::move (v)), next (n), prev (p)
{
}
// this is start of range to remove
// end is inclusive end of range to remove
static void
unhook (Node* begin, Node* end)
{
begin -> prev -> next = end -> next;
end -> next -> prev = begin -> prev;
}
// insert [first,last] before this
void
hook (Node* first, Node* last)
{
first -> prev = prev;
last -> next = this;
prev -> next = first;
prev = last;
}
// insert first before this
void
hook (Node* first)
{
hook (first, first);
}
void
unhook ()
{
Node::unhook (this, this);
}
T data;
Node* next{nullptr};
Node* prev{nullptr};
};
struct Iterator
{
using value_type = List::value_type;
using pointer = List::pointer;
using reference = List::reference;
using difference_type = List::difference_type;
using iterator_category = std::bidirectional_iterator_tag;
public:
Iterator () noexcept = default;
Iterator (Iterator const&) noexcept = default;
Iterator (Iterator&&) noexcept = default;
~Iterator () = default;
Iterator&
operator= (Iterator const&) noexcept = default;
Iterator&
operator= (Iterator&&) noexcept = default;
Iterator (Node const* n) : m_nodePtr (const_cast<Node*> (n))
{
}
reference operator* () const
{
return m_nodePtr->data;
}
pointer operator-> () const
{
return &(m_nodePtr->data);
}
// advances to the "next" pointer, returns reference to self
Iterator&
operator++ ()
{
m_nodePtr = m_nodePtr -> next;
return *this;
}
// advances to the "next" pointer, returns copy of self prior to advancement
Iterator
operator++ (int)
{
iterator temp(*this);
++(*this);
return temp;
}
// advances to the "prev" pointer, returns reference to self
Iterator&
operator-- ()
{
m_nodePtr = m_nodePtr -> prev;
return *this;
}
// advances to the "prev" pointer, returns copy of self prior to advancement
Iterator
operator-- (int)
{
iterator temp(*this);
--(*this);
return temp;
}
// compares the underlying pointers for equality
friend bool
operator== (Iterator const& i, Iterator const& j)
{
return i.m_nodePtr == j.m_nodePtr;
}
friend bool
operator!= (Iterator const& i, Iterator const& j)
{
return !(i == j);
}
private:
Node* m_nodePtr{nullptr};
friend class List;
};
struct ConstIterator
{
using value_type = List::val.
Implement of c & its coding programming by sarmad baloch
Implement of c & its coding programming by sarmad baloch
So here is the code from the previous assignment that we need to ext.pdf
So here is the code from the previous assignment that we need to extend just follow the
instructions above.
main.cpp
#include
#include "Contact.h"
int main()
{
// create Contact object using parameterized constructor
Contact c1("Barbara", "Liskov", "Huberman", "404 Ridgeway Dr", "NC", "27403", "336-274-
3344");
// show contact details
c1.showContact();
cout << endl;
// create Contact object using default constructor
Contact c2;
// test the overloaded input and output operators
cin >> c2;
cout << endl;
cout << c2;
return 0;
}
Address.h
#ifndef ADDRESS_H
#define ADDRESS_H
#include
using namespace std;
// create a class named Address
class Address
{
private:
// private instance variables
string streetAddress, state, zip;
public:
// default constructor
Address()
{
// initialize instance variables with empty strings
streetAddress = "";
state = "";
zip = "";
}
// parameterized constructor
Address(string streetAddress, string state, string zip)
{
// initialize instance variables to given parameters
this->streetAddress = streetAddress;
this->state = state;
this->zip = zip;
}
// copy constructor
Address(const Address &a)
{
streetAddress = a.streetAddress;
state = a.state;
zip = a.zip;
}
// setters for all instance variables
void setStreetAddress(string streetAddress) { this->streetAddress = streetAddress; }
void setState(string state) { this->state = state; }
void setZip(string zip) { this->zip = zip; }
// getters for all instance variables
string getStreetAddress() { return streetAddress; }
string getState() { return state; }
string getZip() { return zip; }
// method to display the address
void showAddress()
{
cout << streetAddress << "\n"
<< state << " " << zip << endl;
}
// declare the overloaded input and output operators
friend ostream &operator<<(ostream &out, const Address &a);
friend istream &operator>>(istream &in, Address &a);
};
// define the overloaded output operator
ostream &operator<<(ostream &out, const Address &a)
{
out << a.streetAddress << "\n"
<< a.state << " " << a.zip << endl;
return out;
}
// define the overloaded input operator
istream &operator>>(istream &in, Address &a)
{
cout << "Enter street address: ";
getline(in, a.streetAddress);
cout << "Enter state: ";
getline(in, a.state);
cout << "Enter zip: ";
getline(in, a.zip);
return in;
}
#endif
Contact.h
#ifndef CONTACT_H
#define CONTACT_H
#include
#include "Name.h"
#include "Address.h"
using namespace std;
// create a class named Contact
class Contact
{
private:
// private instance variables
Name name;
Address address;
string phone;
public:
// default constructor
Contact()
{
// initialize phone with empty string
phone = "";
}
// parameterized constructor
Contact(string first_name, string last_name, string middle_name, string streetAddress, string
state, string zip, string phone)
{
// initialize name and address to given strings
setName(first_name, last_name, middle_name);
setAddress(streetAddress, state, zip);
// initialize phone to the given parameter
this->phone = phone;
}
/.
in c languageTo determine the maximum string length, we need to .pdf
in c language
To determine the maximum string length, we need to create a new callback function that utilizes
an alternative user data structure. This callback function should adhere to the same format as
demonstrated in the example.
The data provided to our callback consists of:
A node containing the node->data pointer, which will store our string.
A userdata argument, represented as (void *), capable of holding any desired content. We
possess complete control over the content at this pointer location, as it will be whatever value we
have passed. Consequently, we can:
Establish a structure to store any pertinent values we require.
Transmit the address of this structure into the function.
use this code and just add your code where it says TO DO
#include
#include
#include
#include
#include "LLGeneric.h"
/** define the maximum length of a line that we can read */
#defineLINE_BUFFER_SIZE1024
/**
* We can use this as our "user data" to help us calculate the maximum
* length string
*
* Add anything else to this structure that you wish
*/
struct maxData {
size_t maxLenSoFar;
char *maxStringSoFar;
};
/**
* our "user function" or "callback" for printing.
*
* We know what "void *userdata" is going to be because it is
* simply what we pass in at the call below, so it is safe to
* cast back to a FILE * as that is what we passed it.
*
* This is called a "callback" as it "call back into" our own
* code from within a generic routine.
*/
int myFindLongestStringNode(GenericListNode *node, int index, void *userdata)
{
/**
* Add more code here. You will need to:
* - convert the GenericListNode payload in the field "data" to your
* known (char *) type
* - conver the (void *) userdata into your known (struct maxData *)
* type
* - use the fact that you can examine and store the values provided
* through the userdata to see what has been calculated by earlier
* calls to this function and update based on what you see here,
* in order to determine what the longest string is in the whole
* set of nodes.
*/
return 1;
}
int
doListActivities(GenericListNode *list)
{
/** create an instance of our structure for use as the user data */
struct maxData maxDataWorkingStruct;
int nProcessed = 0;
/** initialize our structure -- if you added fields, set them up here */
maxDataWorkingStruct.maxLenSoFar = 0;
maxDataWorkingStruct.maxStringSoFar = NULL;
/**
* TO DO: Iterate using the callback, which should calculate what
* the longest string in the list is
*/
nProcessed = lstPerformIterativeAction(
list, /* pointer to the first list node */
myFindLongestStringNode, /* pointer to our function */
(void *) &maxDataWorkingStruct);
/** print out the result */
printf("The longest string has %ld characters\n",
maxDataWorkingStruct.maxLenSoFar);
printf("The longest string is: %s\n",
maxDataWorkingStruct.maxStringSoFar);
return nProcessed;
}
/**
**Tools provided below here you won't need to edit -- they
**simply process the command line, and load and free the
**generic linked list and the st.
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.
array, function, pointer, pattern matching
As a part of the course material of CSC 391- Data structure and algorithm. Review of previous concept of array, pointer and functions.
Frequency .java Word frequency counter package frequ.pdf
Frequency .java
/**
* Word frequency counter
*/
package frequency;
import java.util.Iterator;
/**
*
* @author UMD CS
*/
public class Frequency implements Iterable{
private Node first;
private int N;
Frequency(){
N = 0;
first = null;
}
@Override
public Iterator iterator() {
return new ListIterator();
}
/**
*
* List iterator
*
*/
private class ListIterator implements Iterator{
private Node current;
private int index ;
ListIterator(){
current = first;
index = 0;
}
@Override
public boolean hasNext() {
return current != null;
}
public String next() {
if(!hasNext()){
return null;
}
String word = current.key;
int count = current.count;
String r = \"(\"+word + \",\" + Integer.toString(count)+\")\";
current = current.next;
return r;
}
@Override
public void remove() {
}
}
/**
*
* Node class
*
*/
private class Node {
private String key;
private int count;
private Node next;
Node(String item){
key = item;
count = 1;
next = null;
}
@Override
public String toString(){
return \"(\"+key +\",\"+count+\")\";
}
}
/*
* Inserts a word into the linked list. If the word exists, increment the
* count by q.
*/
public void insert(String word){
if(word.equals(\"\")){
return;
}
//TODO
/*
* implement here
*/
}
/**
*
* @param str input string
* This method splits a string into words and pass the words to insert method
*
*/
public void insertWords(String str){
String delims = \"[ .,?!\'\\\"()}{;/<>&=#-:\\\\ _]+\";
String[] words = str.split(delims);
for(String s: words){
s = s.toLowerCase();
insert(s);
}
}
/**
* prints the word frequency list
*/
public void print(){
Node c = first;
while(c != null){
System.out.print(\"(\"+c.key + \",\" + c.count+\")\");
c = c.next;
}
System.out.print(\"\ \");
}
}
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
WordFrequency.java
package frequency;
import utils.In;
import utils.Stopwatch;
/**
*
* @author UMD CS
*/
public class WordFrequency {
/**
* @param input source
* @param
* This method receives input resource and return the word frequency string
* DO NOT CHANGE THIS METHOD.
*/
public static String freq(String inputSource, int maxLines){
In in;
// Frequency class can only count the frequency of strings. DO NOT CHANGE THIS.
Frequency freq = new Frequency();
int MAX = 100;
String inputSourceName = inputSource;
try {
in = new In(inputSourceName);
while (!in.isEmpty()) {
String s = in.readLine();
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
StringBuilder strFrequency = new StringBuilder();
int cnt = 0;
for(String s: freq){
strFrequency.append(s);
strFrequency.append(\",\");
cnt++;
if(cnt >= maxLines){break;}
}
return strFrequency.toString();
}
/**
*
*/
public static void main(String[] args) {
In in;
Frequency freq = new Frequency();
int MAX = 100;
// String inputSourceName =
\"http://www.cs.umd.edu/class/summer2015/cmsc132/projects/P3_WordFrequency/test1.html\";
String .
mainpublic class AssignmentThree { public static void ma.pdf
// main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
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);.
Similar to #includestdio.h#includestring.h#includestdlib.h#define M.pdf (20)
Easy Understanding of Structure Union Typedef Enum in C Language.pdf
Easy Understanding of Structure Union Typedef Enum in C Language.pdf
Create a JAVA program that performs file IO and database interaction.pdf
Create a JAVA program that performs file IO and database interaction.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned in.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
Use the code below from the previous assignment that we need to exte.pdf
Use the code below from the previous assignment that we need to exte.pdf
include ltfunctionalgt include ltiteratorgt inclu.pdf
include ltfunctionalgt include ltiteratorgt inclu.pdf
Implement of c & its coding programming by sarmad baloch
Implement of c & its coding programming by sarmad baloch
So here is the code from the previous assignment that we need to ext.pdf
So here is the code from the previous assignment that we need to ext.pdf
in c languageTo determine the maximum string length, we need to .pdf
in c languageTo determine the maximum string length, we need to .pdf
maincpp Build and procees a sorted linked list of Patie.pdf
maincpp Build and procees a sorted linked list of Patie.pdf
Frequency .java Word frequency counter package frequ.pdf
Frequency .java Word frequency counter package frequ.pdf
mainpublic class AssignmentThree { public static void ma.pdf
mainpublic class AssignmentThree { public static void ma.pdf
could you implement this function please, im having issues with it..pdf
could you implement this function please, im having issues with it..pdf
More from ANJALIENTERPRISES1
H2SO4 may act as 1) an acidexample 2NaOH + H2SO4 - Na2SO4 +.pdf
to minimise the length, term with \'m\' should be reduced so first to absolute values
must be opened with negative sign S2 = -4m+1 - 5m+6 + 10m-3 S2 = m+4
Solution
to minimise the length, term with \'m\' should be reduced so first to absolute values
must be opened with negative sign S2 = -4m+1 - 5m+6 + 10m-3 S2 = m+4.
Computer graphics are pictures and movies produced use computers fre.pdf
no. of sand grains in 1 truck = 10/0.1 x 10 ^-6=10^8 sand grains total time taken=
(10 X 6.02x10^23 x 10 )/10^8= 6.02 x 10^17 min= 6.872 x 10^ 13 years
Solution
no. of sand grains in 1 truck = 10/0.1 x 10 ^-6=10^8 sand grains total time taken=
(10 X 6.02x10^23 x 10 )/10^8= 6.02 x 10^17 min= 6.872 x 10^ 13 years.
Circle.javaimport java.text.DecimalFormat;public class Circle {.pdf
NaCl - sodium chloride MgO - magnesium oxide AgI - silver iodiode check its not
L CuSO4 - copper sulphate
Solution
NaCl - sodium chloride MgO - magnesium oxide AgI - silver iodiode check its not
L CuSO4 - copper sulphate.
C is correct. Only the host that the unicast message is addressed to.pdf
mol L-1 s-1 is the answer
Solution
mol L-1 s-1 is the answer.
According to the seriousness level, the following organs areThymu.pdf
empirical formula of C2H4 is CH2 empirical formula mass = 12+2 = 14
Solution
empirical formula of C2H4 is CH2 empirical formula mass = 12+2 = 14.
Among 40 subjects randomly choose 20 subjects and assign themSol.pdf
First substance = Ionic solid Second substance = Covalent solid
Solution
First substance = Ionic solid Second substance = Covalent solid.
AdvantagesThe main objective of business combination is to elimina.pdf
ex-1-enol: CH3 - CH2 - CH2 - CH2 - CH2 = CH2-OH hexanal CH3 - CH2 - CH2 -
CH2 - CH2 - CH2=O
Solution
ex-1-enol: CH3 - CH2 - CH2 - CH2 - CH2 = CH2-OH hexanal CH3 - CH2 - CH2 -
CH2 - CH2 - CH2=O.
a. Germ cell speciication in Drosophila is primarily a maternlly con.pdf
coordination no is the no of ligands in the coordination sphere and in this case it is 6
Solution
coordination no is the no of ligands in the coordination sphere and in this case it is 6.
A is correct. The packets to be filtered would be heading into the r.pdf
At the beginning of the 11th year, there would be 1,024,000 rabbits.
Solution
At the beginning of the 11th year, there would be 1,024,000 rabbits..
1). A) ipsilateralBelow the point of spinal cord, the nerve paths .pdf
1). A) ipsilateral
Below the point of spinal cord, the nerve paths belong to the same side (no crossing over occurs).
So, the nociceptive information can be found on the same side of the body.
Solution
1). A) ipsilateral
Below the point of spinal cord, the nerve paths belong to the same side (no crossing over occurs).
So, the nociceptive information can be found on the same side of the body..
17-The Y-Chromosome DNA testing helps in the examination of the male.pdf
17-The Y-Chromosome DNA testing helps in the examination of the male specific portion of the
biological evidence. This is useful where small amount of male DNA is found amidst a large
amount of female DNA , as in the sexual assault cases.It can also help in the missing person
investigation as it extends the range of potential reference samples. Sine the Y chromosome is
passed on from the fathers to their sone (unchanged, except in the case of some mutations),
therefore all the males of the same paternal lineage will possess common Y chromosome
haplotype.
A set of Short tandem repeats (STR) are found on the male specific Y chromosome.The coding
genes found on the short arm of the Ychromosome are vital to male sex determination,
spermatogenesis andother male related functions. The Y-STRs are polymorphic among the
nonrelated males.
Sometimes when sepoarating the mal ecomponent and the female component becomes difficult,
then the YSTRs help in the determination. Since The Y-STRs are not present in the females,
therefore in a case where the male and female are involved, it becomes clear that as the Y-STRs
are present the male component is easily detected as only this part will be amplified in the PCR.
The YSTRs are also helpful when a number of males are involved. As regular STRs cause
masking effect the YSTR will help to identify all the males who have contributed to the
evidence.
ADVANTAGES-
1. extremely discriminating.
2. Extremely sensitive.e. low amounts of DNA can be used for determination.
3. Not onlu body fluids, but alsp touched materials or handled surfaces, where skinn cells ahev
been left can be used for DNA profiling.
4. Multiple testing systems ar available, which increases the likelyhood of successfully
generating DNA profiles.
5. Apart from standart=d STR enem mt DNA or YSTRs are used for profiling.
6. With the presence of the current technologies, from amidst mixed DNA samples, the DNA of
a particular individual can be profiled.
LIMITATIONS
1. Random match probability cannot be excluded.
2. Sometimes even when crime is not committed, we do get ,low levels of DNA on surfaces.
3.The important question while dealing with low DNA quantity is that whether the DNA that
was deposited was deposited during the crime or at some other time.
4.Searching evidence is challenging.
5.Sometimes finding the evidence is altogether impossibl.
6. In case of mtDNA /T STRs , as they are passed on from generation to generation either from
fathers to sons or mothers to daughters and son, therefore sometimes unrelated persons are also
share the same profile.
7. DNA mixtures are very complex.
8.Interpretation is required in many cases.
16- from Cyanobacterial to humans, many terristrial organisms have acquired the circadian
rhythms to adapt to sunlight to increase their survival rate.Circadian Rhythm is a biological clock
that displays an endogenous, entrainable oscillation of 24 hours.Thesse oscillations are driven by
circadian clocks.
PULSE CHASE EXPERIME.
The pH and pOH of a solution are defined as pH .pdf
The pH and pOH of a solution are defined as: pH = -log[H+] pOH = -log[OH-]
and pH + pOH = 14.00 [H+] = 0.055 Conversions: [OH-] = 1.00 x 10^-14 / [H+] = 1.00 x 10-14
/0.055= 1.8x10^-13 pOH = -log[OH-]=12.74
Solution
The pH and pOH of a solution are defined as: pH = -log[H+] pOH = -log[OH-]
and pH + pOH = 14.00 [H+] = 0.055 Conversions: [OH-] = 1.00 x 10^-14 / [H+] = 1.00 x 10-14
/0.055= 1.8x10^-13 pOH = -log[OH-]=12.74.
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, 8, 6, 3, 4, 5] import sys global
count def display_board( state ): #print \"-------------\" print \" %i %i %i \" %
(state[0], state[3], state[6]) #print \"-------------\" print \" %i %i %i \" % (state[1],
state[4], state[7]) #print \"-------------\" print \" %i %i %i \" % (state[2], state[5],
state[8]) #print \"-------------\" def move_up( state ): new_state = state[:] index =
new_state.index( 0 ) if index not in [0, 3, 6]: temp = new_state[index - 1]
new_state[index - 1] = new_state[index] new_state[index] = temp return
new_state else: return None def move_down( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [2, 5, 8]: temp = new_state[index + 1]
new_state[index + 1] = new_state[index] new_state[index] = temp
return new_state else: return None def move_left( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [0, 1, 2]: temp = new_state[index
- 3] new_state[index - 3] = new_state[index] new_state[index] = temp
return new_state else: return None def move_right( state ): new_state =
state[:] index = new_state.index( 0 ) if index not in [6, 7, 8]: temp =
new_state[index + 3] new_state[index + 3] = new_state[index]
new_state[index] = temp return new_state else: return None def
create_node( state, parent, operator, depth, cost ): return Node( state, parent, operator,
depth, cost ) def expand_node( node, nodes ): expanded_nodes = []
expanded_nodes.append( create_node( move_up( node.state ), node, \"u\", node.depth + 1, 0 ) )
expanded_nodes.append( create_node( move_down( node.state ), node, \"d\", node.depth + 1,
0 ) ) expanded_nodes.append( create_node( move_left( node.state ), node, \"l\", node.depth
+ 1, 0 ) ) expanded_nodes.append( create_node( move_right( node.state), node, \"r\",
node.depth + 1, 0 ) ) # Filter the list and remove the nodes that are impossible (move
function returned None) expanded_nodes = [node for node in expanded_nodes if node.state
!= None] #list comprehension! expanded_nodes = [node for node in expanded_nodes if
node not in nodes] #list comprehension! #expanded_nodes = [node for node in
expanded_nodes if node.state!= ((node.parent).parent).state] #list comprehension!
expanded_nodes1 = [] for node in expanded_nodes: temp=node
temp=temp.parent temp=temp.parent if temp==None:
expanded_nodes1.extend(expanded_nodes) break if node.state
!=temp.state: expanded_nodes1.append(node) return
expanded_nodes1 def bfs( start, goal ): nodes = [] count=0 # Create the queue
with the root node in it. nodes.append( create_node( start, None, None, 0, 0 ) ) while
True: # We\'ve run out of states, no solution. if len( nodes ) == 0:
return None # take the node from the front of the queue node = nodes.pop(0)
count=count+1 #display_board(node.state) # Append the move we made to
moves # if this node is the goal, return the moves it took to get here. if node.state
== goal: #display_board(node.state) moves = []
temp = node print cou.
7 steps are required as 9 is the 7th element and the search is line.pdf
7 steps are required as 9 is the 7th element and the search is linear
Solution
7 steps are required as 9 is the 7th element and the search is linear.
(D) the number of moles of hydroxide ion added and the number of mol.pdf
(D) the number of moles of hydroxide ion added and the number of moles of monoprotic acid
initially present
Solution
(D) the number of moles of hydroxide ion added and the number of moles of monoprotic acid
initially present.
Look for changes in oxidation numbers. These occ.pdf
Look for changes in oxidation numbers. These occur in reactions (c) and (e) only.
Thus, reactions (c) and (e) are REDOX reactions.
Solution
Look for changes in oxidation numbers. These occur in reactions (c) and (e) only.
Thus, reactions (c) and (e) are REDOX reactions..
Use Daltons Law of partial pressures. P(Total).pdf
Use Dalton\'s Law of partial pressures. P(Total)=P(H2)+P(H20) p(H2)=P(Total)-
P(H20) Look up the partial pressure of water at the given temperature. It comes out to be 0.0351
atm. P(H2)=1-0.0351 = 0.9649 atm
Solution
Use Dalton\'s Law of partial pressures. P(Total)=P(H2)+P(H20) p(H2)=P(Total)-
P(H20) Look up the partial pressure of water at the given temperature. It comes out to be 0.0351
atm. P(H2)=1-0.0351 = 0.9649 atm.
The Br was originally neutral, but picks up an ex.pdf
The Br was originally neutral, but picks up an extra electron from the N and
becomes Br-. The Br- leaves the molecule The O was originally negative, but gives up an
electron to form a double bond with C1 and becomes neutral. Leaving O=C=N-C as a neutral
molecule. Keeping the labeling of the two carbons it would be O=C1=N-C2. With the double
bonds on both sides of C1, the O, C1, N backbone is linear.
Solution
The Br was originally neutral, but picks up an extra electron from the N and
becomes Br-. The Br- leaves the molecule The O was originally negative, but gives up an
electron to form a double bond with C1 and becomes neutral. Leaving O=C=N-C as a neutral
molecule. Keeping the labeling of the two carbons it would be O=C1=N-C2. With the double
bonds on both sides of C1, the O, C1, N backbone is linear..
More from ANJALIENTERPRISES1 (20)
H2SO4 may act as 1) an acidexample 2NaOH + H2SO4 - Na2SO4 +.pdf
H2SO4 may act as 1) an acidexample 2NaOH + H2SO4 - Na2SO4 +.pdf
Computer graphics are pictures and movies produced use computers fre.pdf
Computer graphics are pictures and movies produced use computers fre.pdf
Circle.javaimport java.text.DecimalFormat;public class Circle {.pdf
Circle.javaimport java.text.DecimalFormat;public class Circle {.pdf
C is correct. Only the host that the unicast message is addressed to.pdf
C is correct. Only the host that the unicast message is addressed to.pdf
According to the seriousness level, the following organs areThymu.pdf
According to the seriousness level, the following organs areThymu.pdf
Among 40 subjects randomly choose 20 subjects and assign themSol.pdf
Among 40 subjects randomly choose 20 subjects and assign themSol.pdf
AdvantagesThe main objective of business combination is to elimina.pdf
AdvantagesThe main objective of business combination is to elimina.pdf
a. Germ cell speciication in Drosophila is primarily a maternlly con.pdf
a. Germ cell speciication in Drosophila is primarily a maternlly con.pdf
A is correct. The packets to be filtered would be heading into the r.pdf
A is correct. The packets to be filtered would be heading into the r.pdf
1). A) ipsilateralBelow the point of spinal cord, the nerve paths .pdf
1). A) ipsilateralBelow the point of spinal cord, the nerve paths .pdf
17-The Y-Chromosome DNA testing helps in the examination of the male.pdf
17-The Y-Chromosome DNA testing helps in the examination of the male.pdf
The pH and pOH of a solution are defined as pH .pdf
The pH and pOH of a solution are defined as pH .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
7 steps are required as 9 is the 7th element and the search is line.pdf
7 steps are required as 9 is the 7th element and the search is line.pdf
(D) the number of moles of hydroxide ion added and the number of mol.pdf
(D) the number of moles of hydroxide ion added and the number of mol.pdf
Look for changes in oxidation numbers. These occ.pdf
Look for changes in oxidation numbers. These occ.pdf
Use Daltons Law of partial pressures. P(Total).pdf
Use Daltons Law of partial pressures. P(Total).pdf
The Br was originally neutral, but picks up an ex.pdf
The Br was originally neutral, but picks up an ex.pdf
Recently uploaded
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
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
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Best Digital Marketing Institute In NOIDA
Safalta Digital marketing institute in Noida, provide complete applications that encompass a huge range of virtual advertising and marketing additives, which includes search engine optimization, virtual communication advertising, pay-per-click on marketing, content material advertising, internet analytics, and greater. These university courses are designed for students who possess a comprehensive understanding of virtual marketing strategies and attributes.Safalta Digital Marketing Institute in Noida is a first choice for young individuals or students who are looking to start their careers in the field of digital advertising. The institute gives specialized courses designed and certification.
for beginners, providing thorough training in areas such as SEO, digital communication marketing, and PPC training in Noida. After finishing the program, students receive the certifications recognised by top different universitie, setting a strong foundation for a successful career in digital marketing.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
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/
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?
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.
Normal Labour/ Stages of Labour/ Mechanism of Labour
Normal labor is also termed spontaneous labor, defined as the natural physiological process through which the fetus, placenta, and membranes are expelled from the uterus through the birth canal at term (37 to 42 weeks
The approach at University of Liverpool.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
CACJapan - GROUP Presentation 1- Wk 4.pdf
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
Embracing GenAI - A Strategic Imperative
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.
Recently uploaded (20)
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk - How can education support child empowerment.pptx
Normal Labour/ Stages of Labour/ Mechanism of Labour
Normal Labour/ Stages of Labour/ Mechanism of Labour
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Multithreading_in_C++ - std::thread, race condition
Multithreading_in_C++ - std::thread, race condition
#includestdio.h#includestring.h#includestdlib.h#define M.pdf
- 1. #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;
- 2. } //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;
- 3. } } //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 );
- 4. 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)
- 5. { 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: