I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C. Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com. You can also call on +1 678 648 4277 for any assistance with C Homework.

1. For any help regarding C Homework Help
visit : - https://www.programminghomeworkhelp.com/ ,
Email :- support@programminghomeworkhelp.com or
call us at :- +1 678 648 4277
C Homework Help

2. Linked List using C Homework Help
The problems:
PS3.0: Node and List
Before you can work on the list operations, you'll need to create both a node and
a list. The node should be responsible for node-y things, and the list for list-y
things, in other words, they won't know much about each other. The list will
accept a filled-in node and add it to the list.
The node should be a struct, and it looks about the same as the one we've seen
in lectures:
typedef struct node { int value; node* next;
}
Here are the signatures for both node's and list's functions. Note that this is just
the starting set of functions; each problem will require you to (possibly) add new
functions to one or both of list and node.
For nodes:
programminghomeworkhelp.com

3. node* createNode(int value); //Create a new node with a given value
For lists:
bool addNode(node* node); //Add a node to the list node* findNode(int
value); //Find a node in the list bool deleteNode (node*
node); //Delete a node in the list
void printList(void); //Print the values in the list
The returned boolean values should indicate success or failure of the
operation.
PS3.1 Add a set of nodes (in main.c)
Create a singly linked list from this array:
[89, 39, 18, 96, 71, 25, 2, 55, 60, -8, 9, 42, 69, 96, 24]
Read each value in turn and call createNode, then addNode. Nodes must be
dynamically allocated using malloc().
Print the list.
programminghomeworkhelp.com

4. PS3.2 Delete the largest nodes
From main, ask the list to delete all of the nodes that contain the largest value
in the list.
The signature for this function will be similar to
void deleteLargest(void);
On the list side, deleteLargest should call an internal list function to find *all*
nodes that contain
the same largest value (there should be more than one), and then call the
internal deleteNode function to delete all of the nodes found. Hint: You can use
an array to collect the largest nodes as you find them.
Print the list.
PS3.3 Count the nodes in the list
From main, ask the list to return the number of nodes in the list, and print the
value.
programminghomeworkhelp.com

5. Solution:
List:
#include <stdio.h>
PS3.4 Sort the list
From main, ask the list to sort itself. Use a bubble-sort algorithm:
•Starting from the top of the list, compare the value in the first node with
the value in the second node
•If the value in the second node is smaller, swap the two nodes, otherwise
leave them in place
•Move to the second node and compare its value with the third node,
swapping them if necessary
•Repeat this until you've reached the end of the list
•Next, go back to the top and do it all over again
•The list is sorted when you walk the entire list from top to bottom and do
not perform any swaps
The list should be sorted in-place. In other words, don't use a second list.
Print the list
programminghomeworkhelp.com

6. #include <stdlib.h>
#include "list.h"
node *head = NULL;
//Add a node to the list bool addNode(node *new_node)
{
if (head == NULL)
{
// This is add node to empty list. Just assign head to new node
head = new_node;
}
else
{
// This is list with elment. Try to add new node to end of list
node *current_node = head;
while (current_node->next != NULL)
{
programminghomeworkhelp.com

7. current_node = current_node->next;
}
// Now we are in end of list. Just add next to current
node current_node->next = new_node;
}
return true;
}
//Find a node in the list node* findNode(int value)
{
node *current_node = head; while (current_node !=
NULL)
{
if (current_node->value == value)
{
// If this node contain value is the same. Just return it
return current_node;
}
// Go the next node for next check current_node =
current_node->next;
}
// Go to end of node. And we can not found anything.
Just return null. return NULL;
programminghomeworkhelp.com

8. }
//Delete a node in the list bool deleteNode(node *del_node)
{
if (head == NULL)
{
// Current list is empty. We can not delete any more return
false;
}
else if (head->value == del_node->value)
{
// If this is delete the head node. node *tmp = head->next;
free(head);
head = tmp; return true;
}
else
{
// If this is delete the middle node node *current_node =
head;
node *prev_node = NULL;
while (current_node != NULL)
{
if (current_node->value == del_node->value)
programminghomeworkhelp.com

9. {
// Find the node to be delete. prev_node->next =
current_node->next; free(current_node);
return true;
}
// If this is not a node delete. Just move to next node
for
checking.
prev_node = current_node; current_node = current_node-
>next;
}
}
// Can not found any node in list for remove. return false;
}
//Print the values in the list void printList(void)
{
node *current_node = head; while (current_node)
{
printf("%d ", current_node->value); current_node = current_node-
>next;
programminghomeworkhelp.com

10. }
printf("n");
}
void deleteLargest(void)
{
// First step is find the largest node int largest_value =
head->value;
node *current_node = head->next; while (current_node)
{
if (current_node->value > largest_value)
{
// If found new node largest. Just keep track it.
largest_value = current_node->value;
}
// Move to next node for check current_node =
current_node->next;
}
// Now try to delete all node largest node. node
*del_node = malloc(sizeof(node)); del_node->value =
largest_value;
programminghomeworkhelp.com

11. del_node->next = NULL;
// Loop until no more largest value in node. while
(findNode(largest_value) != NULL)
{
deleteNode(del_node);
}
free(del_node);
}
int count(void) { int cnt = 0;
node* current_node = head; while(current_node) {
cnt++;
current_node = current_node->next;
}
return cnt;
}
void sort(void) { if(head == NULL) {
// Don't need to sort the empty list
return;
} else
{
programminghomeworkhelp.com

12. if(compare_node->value < current_node->value) {
// We need to swap 2 node
int tmp_value = current_node->value;
current_node->value = compare_node->value;
compare_node->value = tmp_value;
}
compare_node = compare_node->next;
}
current_node = current_node->next;
}
}
}
Main:
#include <stdio.h>
#include <stdlib.h>
#include "node.h"
#include "list.h"
int main(int argc, char** argv) {
// PS3.1 - Add a set of nodes.
node* current_node = head; node*
compare_node = NULL; while(current_node)
{
compare_node = current_node->next;
while(compare_node) {
programminghomeworkhelp.com

13. // Create a signly linked list from this array. [89, 39,
18, 96, 71,
25, 2, 55, 60, -8, 9, 42, 69, 96, 24]
int array[15] = {89, 39, 18, 96, 71, 25, 2, 55, 60, -8,
9, 42, 69, 96,
24};
for(int i = 0; i < 15; i++) {
node* new_node = createNode(array[i]);
addNode(new_node);
}
// Print list
printf("PS3.1 - List after add: "); printList();
printf("========================================
===n");
// PS3.2 Delete the largest nodes
printf("PS3.2 - Try to delete the largest node.n");
deleteLargest();
printf("List after delete: "); printList();
printf("========================================
===n");
// PS3.3 - Count the nodes in the list printf("PS3.3 -
Count the nodes in the listn"); int list_size = count();
printf("Count nodes in list: %dn", list_size);
programminghomeworkhelp.com

14. //Create a new node with a given value node* createNode(int
value)
{
// Allocate a new node
node *new_node = (node*) malloc(sizeof(node)); if (new_node)
{
// Check the allocated is successfull new_node->value = value;
new_node->next = NULL;
}
return new_node;
}
// PS3.4 - Sort the list printf("PS3.4 - List after sort: ");
sort();
printList();
// j o h n n y t u o t - g m a i l - c o m return 0;
}
Node:
#include <stdio.h>
#include <stdlib.h>
#include "node.h"
programminghomeworkhelp.com