Linked List Using C Homework Help: The Problems: PS3.0: Node and List

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.
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.
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>
#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)
{
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;
}
//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)
{
// 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;
}
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;
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++;
}
return cnt;
}
void sort(void) { if(head == NULL) {

// Don't need to sort the empty list
return;
} else
{
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;
}
}
}
}
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.
// 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");
// 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;
}

Linked List Using C Homework Help: The Problems: PS3.0: Node and List

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linked List Using C Homework Help: The Problems: PS3.0: Node and List

Uploaded by

Copyright:

Available Formats

Linked List using C Homework Help

typedef struct node { int value; node* next;

The returned boolean values should indicate success or failure

PS3.1 Add a set of nodes (in main.c)

Create a singly linked list from this array:

Read each value in turn and call createNode, then addNode.

On the list side, deleteLargest should call an internal list function

Print the list.

PS3.3 Count the nodes in the list

From main, ask the list to sort itself. Use a bubble-sort

node *head = NULL;

//Add a node to the list bool addNode(node *new_node)

// Now try to delete all node largest node. node *del_node =

int count(void) { int cnt = 0;

void sort(void) { if(head == NULL) {

int main(int argc, char** argv) {

//Create a new node with a given value node*

You might also like