CSCI2100B Linked List Jeffrey Yu@CUHK

1. CSCI2100B Linked ListJeffrey Yu@CUHK

2. 20 40 12 65 insert 30 Problems of Arrays in Implementation • Let the base address of an array to be a. The address of the i-th element is located ata + (i - 1) * sizeof(theTypeOfElement). We can access an element in an array in constant time if we know its array index. • But, suppose that we have stored four integers (12, 20, 40, 65) in an array and we want to insert an integer 30as the third-element in the array. What is the cost? Linked List

3. Linked List • Unlike an array, with a linked list representation (singly linked list, double linked list, etc.), elements can be placed anywhere in memory. • With singly linked list, an element is a “node” which has two parts: • A data component. • A pointer to the next element in the list. • An exampletypedefstructlistNode *listPointer;typedefstructlistNode {int data;listPointer link;}; Linked List

4. data data data link link link 12 20 40 65 30 A Singly Linked List Example listPointer l NULL • What is the advantage/disadvantage of the singly linked representationin terms of read/update values and insertion/deletion of nodes? Linked List

5. Implementation of Singly Linked List listPointercreate(){ return (listPointer)NULL; } Boolean IsEmptyL(listPointerl){ if (l == NULL) return TRUE; else return FALSE; } int main() { listPointer l; l = create(); ... } • NULL is used as 0 meaning empty and false in C language. NULL does not have a type. (ListPointer)NULL means that it is a NULL value with the type of ListPointerlike(int*)NULL. Linked List

6. 12 20 40 65 listPointer l NULL The Length and the nth Position • Consider a list. • The size of a list is the number of elements. If a list is empty (NULL), the number is zero. • The nth position of a list is the n-th element of the list. The first element is at the 0-th position. Linked List

7. 12 20 40 65 listPointer l NULL The Length and the nth Position listPointer nth(listPointer l, int index){ /* returns the indexed element */ listPionter move = l; while (index >0) {move = move->link; index--;} return move; } intlength(listPointer l){ /* returns the length of list */ listPointer move = l; int i = 0; while (move != NULL) { i++; move = move->link;} return i; } Linked List

8. 12 20 40 65 prev listPointer l next NULL Singly Linked List: Last listPointer last(listPointer l){ /* returns ptr to the last list element */ listPointerprev, next; if (IsEmptyL(l)) return NULL; prev = l; next = prev->link; while (next != NULL) { prev = next; next = prev->link; } return prev; } Linked List

9. 12 20 40 65 e listPointer l tmp NULL Singly Linked List: Prepend listPointer prepend(listPointer l, int e){ /* insert to the front of list */ listPointertmp; tmp = (listPointer)malloc(sizeof(listNode)); tmp->data = e; if (IsEmptyL(l)) { tmp->link = NULL; return tmp; } else { tmp->link = l; l = tmp; return l; } } Linked List

10. 12 20 40 65 listPoniter l end e NULL NULL Singly Linked List: Append listPointer append(listPointer l, int e){ /* append an element at the end*/ listPointer end; if (IsEmptyL(l)) return prepend(l, e); end = last(l); end->link = prepend(NULL, e); return l; } Linked List

11. 12 20 40 65 listPointer l NULL Singly Linked List: Delete • Consider deleting an element from a list. • The delete procedure is to delete an element from a list l specified by trial, and return the new deleted list.listPointer delete(listPointer l, listPointer trail) • There are three cases about trail. • To delete the first element (trail == NULL) • To delete the last element (trail == last(l)) • To delete an element in the middle (trail is the precedent node of the node to be deleted) Linked List

12. 12 20 40 65 listPointer l NULL Singly Linked List: Delete listPointer delete(listPointer l, listPointer trail){ /* delete from a node from a list at the position specified by trail */ listPointer w, t, p; if (IsEmptyL(trail)) { /* delete the first node */ w = l; l = l->link; } else { t = last(l); if (trail == t) { /* assume the list l is long enough */ w = trail; p = nth(l, length(l) - 2); p->link = NULL; } else { w = trail->link; trail->link = trail->link->link; } } free(w); return l; } Linked List

13. Another Set of Operations • In the textbook (Section 4.2 -- Chapter 4, Section 2), it offers two operations to insert/delete a node into/from a list. • Read Section 4.2. And consider the differences to manipulate lists. Linked List

14. Dynamically Linked Stack typedefstruct { listNode*element; /* For listNode, refer to the slide 4-3 */ } stack; stack *createS(){ stack *s; s = (stack*)malloc(sizeof(stack)); s->element = NULL; return s; } Boolean IsEmptyS(stack *s){return IsEmptyL(s->element);} Linked List

15. Dynamically Linked Stack void push(stack *s, int e){ s->element = prepend(s->element, e); } int pop(stack *s){ inti; listPointer t; if (!IsEmptyS(s)) { t = nth(s->element, 0); i = t->data; s->element = delete(s->element, NULL); /* delete the first */ return i; } else printf("Error\n"); } Linked List

16. Dynamically Linked Queue typedefstruct { listNode*element; /* For listNode, refer to the slide 4-3 */ } queue; queue *createQ(){ queue *q; q = (queue*)malloc(sizeof(queue)); q->element = NULL; return q; } Boolean IsEmptyQ(queue *q){ return IsEmptyL(q->element); } Linked List

17. Dynamically Linked Queue void enqueue(queue *q, int e){ q->element = append(q->element, e); } intdequeue(queue *q){ inti; listNode*t; if (!IsEmptyQ(q)) { t = nth(q->element, 0); i = t->data; q->element = delete(q->element, NULL); return i; } else printf("Error\n"); } Linked List

18. Doubly Linked List • Singly linked lists sound good. • But, we can only traverse from one to the next, and we cannot traverse from one to its previous. When we want to know the previous, we have to search from the beginning of the list. • A solution is to add one more list-node pointer into list node. (Read Section 4.8 of the text book.) • An exampletypedefstructnode *nodePointer;typedefstructnode {int data;nodePointerllink; /* point to the left node */nodePointerrlink; /* point to the right node */}; Linked List

19. llink data rlink llink llink llink data data data rlink rlink rlink 12 12 30 20 Doubly Linked List: An Example Linked List

20. Doubly Linked List typedefstruct node *nodePointer; typedefstruct node {int data;nodePointerllink; /* point to the left node */nodePointerrlink; /* point to the right node */}; nodePointercreateDL(int e){ nodePointertmp; tmp = (nodePointer)malloc(sizeof(dlist)); tmp->data = e; tmp->llink = tmp; tmp->rlink = tmp; return tmp; } • Suppose ptrpoints to any node in a doubly linked list. Then: ptr == ptr->llink->rlink == ptr->rlink->llink Linked List

21. llink llink llink llink data data data data rlink rlink rlink rlink 12 20 18 30 newnode node Doubly Linked List: dinsert void dinsert(nodePointer node, nodePointernewonde) { /* insert the newnode into the rightof the node*/ newnode->llink = node; newnode->rlink= node->rlink; node->rlink->llink = newnode; node->rlink= newnode; } Linked List

22. llink llink llink data data data rlink rlink rlink 12 20 30 node Doubly Linked List: ddelete void ddelete(nodePointer node, nodePointer deleted){ if (node == deleted) printf("deletion of head is not permitted.\n"); else { deleted->llink->rlink = deleted->rlink; deleted->rlink->llink = deleted->llink; free(deleted); } } deleted Linked List

23. Lists v.s. Arrays • Question-1: Do you know how many elements you need to handle? (max number? exact number? ...) • Question-2: How do you use lists/arrays? • Access elements (read/update values) • Insert/delete elements • Forsingly/doubly linked lists, we need to consider the insert/delete elements into/from a list at the cost of one more pointer. Linked List