1. CH Gowri Kumar gkumar007@gmail.com
9/21/2018
Linked Lists
CH Gowri Kumar

2. typedef struct node Node; typedef struct node* List;
9/21/2018
struct node {
int data;
struct node* next; };
typedef struct node Node;
typedef struct node* List;
List Initialize();
void InsertBegin(List l,int d);
void InsertEnd(List l, int d);
void Insert(List l, Node* pos,int d);
Node* Find(List l,int d);
void Delete(List l, int d);
This is header based implementation of linked lists.
The typedefs help us to reduce the amount of typing. Instead of typing
“struct node*” all the time, we can just use Node*;
Initiliaze – Creates a dumy header node and returns it.
InsertBegin – The element is inserted at the beginning of the list
InsertEnd – The element is inserted at the end of the list.
Insert – The general routine, inserts the elment after the node “pos”.
Find – Return the node, whose next node points to the actual node.
The intended use is:
Node* p = Find(l,10);
p->next->data == 10
If the element is no there in the list, it returns NULL.
Delete – deletes the element d from the list.
September 21, 2018

3. Menu Initialize InsertBegin InsertEnd Insert Find Delete
September 21, 2018

4. Initialize
September 21, 2018

5. temp = (Node*)calloc(1,sizeof(Node)); return temp; }
9/21/2018
List Initialize() {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
return temp; }
We would be using calloc in our implementation, instead of malloc.
He difference between calloc and malloc is that:
Malloc – just allocates the memory
Calloc – Allocates the memory and also clears it. The initial values would be
Data would be 0 and the next would be NULL.
If we had used malloc, the code would have been:
Node* temp;
Temp = (Node8)malloc(sizeof(Node));
Temp->next = NULL;
Return temp;
The intended use of the Initialize is as follows:
List head;
Head=Initialize();
September 21, 2018

6. temp = (Node*)calloc(1,sizeof(Node)); return temp; } main() {
9/21/2018
head X
List Initialize() {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
return temp; }
main() {
List head;
head = Initialize(); }
We would be using calloc in our implementation, instead of malloc.
He difference between calloc and malloc is that:
Malloc – just allocates the memory
Calloc – Allocates the memory and also clears it. The initial values would be
Data would be 0 and the next would be NULL.
If we had used malloc, the code would have been:
Node* temp;
Temp = (Node8)malloc(sizeof(Node));
Temp->next = NULL;
Return temp;
The intended use of the Initialize is as follows:
List head;
Head=Initialize();
September 21, 2018

7. InsertBegin
September 21, 2018

8. 1 10 8 4 6 3 2 5 head X September 21, 2018 http://www.gowrikumar.com
9/21/2018 1 10 8 4 6 3 2 5
head X
Let’s try inserting a few elements shown above into the list.
September 21, 2018

9. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; }
Let’s try inserting a few elements shown above into the list.
September 21, 2018

10. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; } 1
First we create a node temp, using calloc and copy the value into it.
Now we need to insert the node into the list.
For that first we make temp->next point to whatever head->next is pointing to.
Then we make head->next point to temp;
Here in this case, head->next is NULL, so you may think that it is not necessary to have the
Statement temp->next = head->next; we will see the explanation for it when we insert another node
At the beginning of the list.
September 21, 2018

11. 1 10 8 4 6 3 2 5 head X 1 September 21, 2018 http://www.gowrikumar.com
9/21/2018 1 10 8 4 6 3 2 5
head X 1
Now the list looks this
September 21, 2018

12. void InsertBegin(List head,int d) { Node* temp; 1 10 8 4 6 3 2 5
head X
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; } 1
September 21, 2018

13. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; } 1
The order of operations of the nodes is important. To understand it better, let’s try
To interchange the instructions and see what happens.
September 21, 2018

14. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
head->next = temp;
temp->next = head->next; } 1
If we execute head->next = temp first, we lose the remaining of the list.
And if we execute the next statement, temp->next would be pointing to itself.
September 21, 2018

15. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X 1
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; }
Now let us insert 10 into the list at the beginning of the list.
September 21, 2018

16. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X 1
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = head->next;
head->next = temp; } 10
It is similar to the earlier insertion. Here it should make clear why temp->next has to be assigned
Head->next; Here we have remaining list to be taken care of (earlier it was an empty list).
September 21, 2018

17. void InsertBegin(List head,int d) { Node* temp;
9/21/2018 1 10 8 4 6 3 2 5
head X 1
void InsertBegin(List head,int d) {
Node* temp;
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
head->next = temp;
temp->next = head->next; } 10
As said earlier, the order of pointer manipulations is important.
September 21, 2018

18. InsertEnd
September 21, 2018

19. void InsertEnd(List head,int d) { Node *tail,*temp; tail = head;
9/21/2018 1 10 8 4 6 3 2 5
head X 10 1
tail
void InsertEnd(List head,int d) {
Node *tail,*temp;
tail = head; }
Now let’s insert 8 into the linked-list, but to the end of the list.
September 21, 2018

20. void InsertEnd(List head,int d) { Node *tail,*temp; tail = head;
9/21/2018 1 10 8 4 6 3 2 5
head X 10 1
tail
void InsertEnd(List head,int d) {
Node *tail,*temp;
tail = head;
while(tail->next != NULL)
tail = tail->next; }
First we need to go to the end of the list. For that we initialize tail to point head and
Traverse the list using a while loop, with tail = tail->next, as the loop statement.
September 21, 2018

21. void InsertEnd(List head,int d) { Node *tail,*temp; tail = head;
9/21/2018 1 10 8 4 6 3 2 5
head X 10 1
tail
void InsertEnd(List head,int d) {
Node *tail,*temp;
tail = head;
while(tail->next != NULL)
tail = tail->next; }
When the loop terminates, tail is pointing to the last element. Note that we want to point to the last element and not to NULL.
September 21, 2018

22. void InsertEnd(List head,int d) { . . . . . . . .
9/21/2018 1 10 8 4 6 3 2 5
head
tail X 10 1 8
void InsertEnd(List head,int d) {
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
tail->next = temp; }
A new node is created and the last node’s next pointer is made to point to this new node.
Because, calloc takes care of initializing the next to NULL, we don’t have to worry about pointing it to NULL.
September 21, 2018

23. Insert
September 21, 2018

24. void Insert(List head,Node* p,int d) {
9/21/2018 1 10 8 4 6 3 2 5
head X 10 1 8
void Insert(List head,Node* p,int d) {
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = p->next;
p->next = temp; }
Now let’s look at the general version of Insert, where the element is to be inserted after the node.
September 21, 2018

25. void Insert(List head,Node* p,int d) {
9/21/2018 1 10 8 4 6 3 2 5
head X 10 1 8 4
void Insert(List head,Node* p,int d) {
temp = (Node*)calloc(1,sizeof(Node));
temp->data = d;
temp->next = p->next;
p->next = temp; }
Now let’s look at the general version of Insert, where the element is to be inserted after the node.
September 21, 2018

26. 1 10 8 4 6 3 2 5
head X 10 1 4 8
September 21, 2018

27. Find
September 21, 2018

28. void Find(List l,Node* p,int d) { Node *temp; temp = l; 1 10 8 4 6 3 2 5
head X 10 1 4 8
void Find(List l,Node* p,int d) {
Node *temp;
temp = l;
while(temp->next != NULL)
if(temp->next->data == d)
return temp;
temp = temp->next; }
return NULL;
September 21, 2018

29. void Find(List l,Node* p,int d) { Node *temp; temp = l; 1 10 8 4 6 3 2 5
head
temp X 10 1 4 8
void Find(List l,Node* p,int d) {
Node *temp;
temp = l;
while(temp->next != NULL)
if(temp->next->data == d)
return temp;
temp = temp->next; }
return NULL;
September 21, 2018

30. Delete
September 21, 2018

31. void Delete(List l,Node* p,int d) { Node *temp,*del; temp = Find(l,d); 1 10 8 4 6 3 2 5
head X 10 1 4 8
void Delete(List l,Node* p,int d) {
Node *temp,*del;
temp = Find(l,d);
if(temp != NULL)
del = temp->next;
temp->next = del->next;
free(del); }
September 21, 2018

32. void Delete(List l,Node* p,int d) { Node *temp,*del; temp = Find(l,d); 1 10 8 4 6 3 2 5
head
temp
del X 10 1 4 8
void Delete(List l,Node* p,int d) {
Node *temp,*del;
temp = Find(l,d);
if(temp != NULL)
del = temp->next;
temp->next = del->next;
free(del); }
September 21, 2018

33. 10 8 4 6 3 2 5
head X 10 4 8
September 21, 2018

34. int main { List l; Node* temp; l = Initialize(); InsertBegin(l,1);
InsertEnd(l,8);
temp = Find(l,8);
Insert(l,temp,4);
Delete(l,1); }
September 21, 2018

35. The End
September 21, 2018