Download presentation

Presentation is loading. Please wait.

1
**CSCI2100B Linked List Jeffrey Yu@CUHK**

2
**Problems of Arrays in Implementation**

Let the base address of an array to be a. The address of the i-th element is located at a + (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 30 as the third-element in the array. What is the cost? 12 20 40 65 insert 30 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 example typedef struct listNode *listPointer; typedef struct listNode { int data; listPointer link; }; Linked List

4
**A Singly Linked List Example**

listPointer l 30 data link 12 data link 20 40 65 data link NULL What is the advantage/disadvantage of the singly linked representation in terms of read/update values and insertion/deletion of nodes? Linked List

5
**Implementation of Singly Linked List**

listPointer create(){ return (listPointer)NULL; } Boolean IsEmptyL(listPointer l){ 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 ListPointer like (int*)NULL. Linked List

6
**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. listPointer l 12 20 40 65 NULL Linked List

7
**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; } int length(listPointer l){ /* returns the length of list */ listPointer move = l; int i = 0; while (move != NULL) { i++; move = move->link;} return i; } listPointer l 12 20 40 65 NULL Linked List

8
**Singly Linked List: Last**

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

9
**Singly Linked List: Prepend**

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

10
**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; } listPoniter l end e NULL 12 20 40 65 NULL Linked List

11
**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) listPointer l 12 20 40 65 NULL Linked List

12
**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; listPointer l 12 20 40 65 NULL Linked List

13
**Another Set of Operations**

In the textbook (Section 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**

typedef struct { 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){ int i; 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**

typedef struct { 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); } int dequeue(queue *q){ int i; 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 example typedef struct node *nodePointer; typedef struct node { int data; nodePointer llink; /* point to the left node */ nodePointer rlink; /* point to the right node */ }; Linked List

19
**Doubly Linked List: An Example**

12 data rlink llink 12 data rlink llink 20 30 Linked List

20
**Doubly Linked List typedef struct node *nodePointer;**

typedef struct node { int data; nodePointer llink; /* point to the left node */ nodePointer rlink; /* point to the right node */ }; nodePointer createDL(int e){ nodePointer tmp; tmp = (nodePointer)malloc(sizeof(dlist)); tmp->data = e; tmp->llink = tmp; tmp->rlink = tmp; return tmp; } Suppose ptr points to any node in a doubly linked list. Then: ptr == ptr->llink->rlink == ptr->rlink->llink Linked List

21
**Doubly Linked List: dinsert**

void dinsert(nodePointer node, nodePointer newonde) { /* insert the newnode into the right of the node*/ newnode->llink = node; newnode->rlink = node->rlink; node->rlink->llink = newnode; node->rlink = newnode; } 18 data rlink llink newnode node 12 data rlink llink 20 30 Linked List

22
**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); } node 12 data rlink llink 20 30 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 For singly/doubly linked lists, we need to consider the insert/delete elements into/from a list at the cost of one more pointer. Linked List

Similar presentations

OK

Data Structure Lecture-3 Prepared by: Shipra Shukla Assistant Professor Kaziranga University.

Data Structure Lecture-3 Prepared by: Shipra Shukla Assistant Professor Kaziranga University.

© 2018 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google