Linked lists in C. By Marina Barsky

Transcription

1 Linked lists in C By Marina Barsky

2 Keeping sequence in order Busy day, 1 sheet of paper 1 To do: 2 Dry cleaning 3 Bank 4 Lunch with Bob 5 Haircut Suddenly we remember that we need to buy stamps, and the post office is next to Dry cleaners How do we insert this task before Bank? Should we discard this plan and start a new list on another sheet of paper? Inventing linked list 1 To do: 2 Dry cleaning 3 Bank 4 Lunch with Bob 5 Haircut 6 Stamps We have some space down the list We can write stamps there and use arrows to imply the desired order We put our data elsewhere and we use links to maintain the order This is the main idea behind the linked list

3 Two ways for storing a sequence of values A[0] A[1] A[2] A[3] data data data data Array Pointer to (address of) the first element of an array: A [0] List node List node List node head data link to next node data link to next node data link to next node Linked list Pointer to the first node

4 Linked list vs. array Linked list Not limited in size Insertion or deletion of a node is performed by updating links Access to an indexed position requires sequential scan from the head of the list Array Limited in size. Need to re-allocate memory to grow Insertion or deletion of an element may require to move multiple elements Access to an indexed position is performed by adding an index to an address of the first element of an array: constant-time random access Memory overhead to store links

5 Operations on lists Traverse the list Add new node Remove a node

6 Traversing the list node A node B node C data: 2 data: 3 data: 4 head: pointer to node A node B node C nothing 1. Head is all we need to know 2. We follow the sequence by following the links 3. We stop when there is no link to the next node

7 Adding a new node at the beginning of the list node A node B node C data: 2 node B data: 3 node C data: 4 nothing head: points to node A node D data: 1 nothing 1. Create new node 2. Chain it into the list by setting its next link to the old first node, pointed to by head 3. Update the head of the list: it is now pointing to node C

8 Removing the first element node A node B node C data: 2 node B data: 3 node C data: 4 nothing temp: points to node A head: points to node B 1. Copy a link to node A to destroy it later 2. Set head to point to nodea->next (node B) 3. Destroy node A

9 Puzzle 1: concatenate two lists Pointer to the first node listhead1 data: 2 data: 3 data: 4 NULL a b c Pointer to the last node listtail1 Pointer to the first node listhead2 data: 5 data: 6 Pointer to the last node listtail2 d e listtail1->next = listhead2 listtail1 = NULL; listhead2=null;

10 Puzzle 2: Circular list Pointer to the first node listhead1 data: 2 data: 3 data: 4 NULL a b c Pointer to the last node listtail1 listtail1->next = listhead1 listtail1 = NULL;

11 Puzzle 3: Reverse order Pointer to the first node listhead1 data: 2 data: 3 data: 4 NULL Pointer to the last node listtail1 void reverse (node *& a head, node * & tail) b c node *headofreverse = NULL; node * current = head; Move each next node node * next = NULL: in front of a while (current!= NULL) reverseresult list next = current->next; //store pointer to the next node current->next = headofreverse; //push on top of reverse list headofreverse = current; current = next; //advance in the original list head = headofreverse ;

12 Explaining the linked list concept to a computer: code Define a node structure with 2 fields Declare a variable of type node pointer: the head of the list typedef struct node int data; node *next; node; node * head; typedef struct node int data; node *next; node;

13 What happens in memory Stack Heap struct node int data; node *next; ; head int main() node * head; When the program starts, space to hold one pointer is allocated on the stack We can access this memory location through a variable named head There is nothing inside this memory cell: a special value of NULL (address=0) Variable head is local to main, and is therefore stored in the stack When main is finished running, the space occupied by this variable is reclaimed

14 1-2-3 list Stack Heap struct node int data; node *next; ; Now contains an address of node a head data: 2 data: 3 data: 4 node * head; NULL node * a = (node *)malloc (sizeof(node)); a->data = 2; node * b = (node *)malloc (sizeof(node)); b->data = 3; node *c = (node *)malloc (sizeof(node)); c->data = 4; a->next = b; b->next = c; head = a; a b c This creates 3 disjoint nodes on the heap Variable head is a local variable of a function create123list, once the function is finished, it will be destroyed. Not so with nodes: they are created on the heap with a new keyword. They will still be there after the function ended.

15 Function for getting the length of the list int listlength(node * head) int count =0; node *current = head; while (current!= NULL) count++; current = current->next; return count; int main () int length = listlength (head); printf ( %d elements in the list.\n, length);

16 Function for adding at the beginning of the list void addontop (node * head, int value) node * d = (node *)malloc (sizeof(node)) d->data = value; if (head == NULL) head = d; else d->next = head->next; head = d; What is wrong???? int main () addontop (head, 1); int length = listlength (head); printf ( %d elements in the list.\n, length);

17 The pointer node * head is passed by value! type: pointer head void addontop (node * head, int value) When we pass to the function an argument of type node pointer, it creates a copy of type node pointer, that is a new variable that points to the same thing that head points to, we can change this copy but we cannot change the head itself

18 The pointer node * head is passed by value! Stack ; Variables local to main Address of node a head length Variables local to addontop Address of node a headptr (copy of head) 0 value Address of node a current void addontop (node * headptr, int value) node * d = (node *)malloc (sizeof(node)); d->data = value; if (head == NULL) data: 2 Heap data: 3 Node d is created on the heap, and lives there However any reference to it is lost, because we updated a local variable headptr, but not the head itself struct node int data; node *next; data: 4 NULL a b c

19 The pointer node * head is passed by value! type: pointer head void addontop (node * head, int value) d->next = head->next; type: pointer head = d; local copy of head Inside the function, we set this copy to point to a newly added node, but that does not move the original head! When we done with the function, all its local variables are destroyed, and the original head remains unchanged!

20 Reminder: passing by value void increment (int x) x++; int main () x=5; increment (x); printf ( x=%d,x); return 0; If we pass a parameter to a function as is, the local copy is created and the only way to get the changed value is though return

21 Reminder: passing by reference (passing an address) void increment (int * x) (*x)++; int main () x=5; increment (&x); printf ( x=%d,x); return 0; Dereference: operator * If we pass an address of the variable instead, function will change the value pointed to by this address (address is copied, but now both the original and the copy point to the same memory location, and they share responsibility for the value stored in this location Send the reference to x

22 Passing address of node * head void addontop (node ** head, int value) node * d = (node *)malloc (sizeof(node)); d->data = value; type: pointer head if (*head == NULL) *head = d; else d->next = *head->next; *head = d; Dereference to change the inside of the head variable int main () addontop (&head, 1); listlength (head); Passing an address of head pointer

23 The pointer to the location of head head is now passed Stack Variables local to main Address of node a head length Variables local to addontop Address of head headptr 0 value Address of node a current void addontop (node * headptr, int value) node * d = (node *)malloc (sizeof(node)); d->data = value; data: 2 Heap data: 3 Node d is created on the heap, and lives there However any reference to it is lost, because we updated a local variable headptr, but not the head itself struct node int data; node *next; ; data: 4 NULL a b c

24 Stack as linked list Head on top Last in first out head type: pointer Need only pointer to the top (head) of the stack b data: 2 a data: 1 NULL

25 head c Push type: pointer data: 3 Add new element on top of the stack in the beginning of the list b data: 2 a data: 1 NULL

26 head Pop type: pointer Remove top element and return it c data: 3 b data: 2 a data: 1 NULL

27 Summary. Linked list Advantages Can hold unlimited number of elements Add/Remove in the beginning and the end are cheap Add/Remove in the middle require some work, but does not require moving other elements Disadvantages No constant-time access to every element by its position Memory overhead (to store pointers) Cannot improve search even if the list is sorted (totally sequential access)

28 App 1: HR stack hire fire nexttofire printlist

29 App 2: Hospital queue