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:

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
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.

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
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.

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
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

Solution:

List:
#include <stdio.h>

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
#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)
{

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
 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;

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
}
//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)

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
{
// 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;

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
}
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;

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
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
{

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
node* current_node = head; node*
compare_node = NULL;
while(current_node) {
compare_node = current_node->next;
while(compare_node) {
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.
© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
// 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 list\n"); int list_size = count();
printf("Count nodes in list: %d\n", list_size);
printf("=====================================
======\n");

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers
// 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"

//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;
}

© 2022 All Rights Reserved. Programming Homework Help | Expert Homework Helpers