You will implement singly linked lists in C. You will test your program by creating an ordered linked list of integers. You will then use your implementation to write a program that creates a representation of a deck of cards and makes a random shuffle of the deck. The algorithms for implementing linked lists will be discussed in your classes. Therefore, this description does not list implementation details of the required functions.

Detailed requirements for linked lists implementation:

You will need to write several functions.

0. To represent a node in a linked list you can use a structure

typedef struct Node

{

SomeDataType data;

struct Node *next;

} ListNode;

where SomeDataType can be any C data type.

1. Write a function to make a new list. Your function should create a dummy head node to represent an empty list.

ListNode *newList(void) // returns a head of a new empty list

2. Write functions to insert elements into a list and to remove elements from a list

ListNode *removeNode(ListNode * prev); // removes the node after prev

ListNode *insertNode(ListNode *prev, SomeDataType data) // inserts a new node with data field data after prev

3. Write functions to count the number of elements in a list without the head and to print the list

int length(ListNode *head) // number of elements in the list

void printList(ListNode *head) // print the data fields for the entire list Note that printList will print the linked list implemented to support the second part of your project.

To test your code you will use it to make an ordered list of random integers. After that you will write functions to manipulate a deck of cards. You should assume that a full deck contains 52 cards: card values (A,2,3,4,5,6,7,8,9,10,J,Q,K) in four suits (Spades,Diamonds,Hearts,Clubs). You can use either integers or enums to represent cards and suits, but you should print card values using their symbols (A,2,. . . ,10,J,Q,K) and the suits using first letter of their name. Examples: (10,S),(A,C),(7,D) to stand for 10 of spades, ace of clubs, and 7 of diamonds.

Detailed instructions for ordered list of integers implementation: To test your linked list code you should generate 10 random numbers in the range [0..1000] and insert them in a ascending order into an empty list. Every time you generate a number you need to traverse the linked list and find a proper place for the number to be inserted. This means that you should not sort numbers before insertion. You should calculate the list length and print it together with the list after each number insertion. Note that for this part to work your data field should be of type int.

Detailed requirements for deck of cards manipulation: You will write a function to make a deck and a function to shuffle a deck of cards. To make a deck you loop through card values and suits and create pairs of values to represent the cards; those pairs are then inserted into the list representing the deck. To shuffle the deck you will write a random shuffle method that works as follows.

struct Node *randomShuffle(struct Node *olddeck) // returns new deck

{ int len = length(olddeck) Make a new linked list newdeck

for (int i=len-1; i>=0; i- -)

} j = random()%(i+1) move the jth card from olddeck to the front of newdeck

}

return newdeck

}

You can use removeNode and insertNode functions to move the cards from one deck to another. If you know how to do it you can just move a node while setting all links properly.

Basically it will be two different files that performs two different implementation with linked list. The first implementation is to insert, remove using integer

The second implementation is to do it with the card struct.