Data Structure

Linked Lists
Chapter 2

Linked Lists / Slide 2

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 3

Why do we need Link List

Problems

with arrays

Size has to be pre-defined Insertion and deletion are costly operations

Ordered Array

E.g.,

B
C C

Insert

Linked Lists / Slide 4

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 5

HEAD A

Memory representation
B TEST D .. G LINK NULL

AVAIL AVAIL AVAIL AVAIL AVAIL

1 4 6 7

HEAD

1 2 3

1 B
D G

4
5 6 7 8

6
7

NULL

Linked Lists / Slide 6

Allocation of memory
the new operator to allocate an array dynamically An array name is a pointer to the arrays first element Malloc and Calloc can also be used to dynamically allocate memory
Use

Linked Lists / Slide 7

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 8

Linked Lists
A Head Item Next B C

linked list is a series of connected nodes Each node contains at least

A piece of data (any type) Pointer to the next node in the list
node

Head:

pointer to the first node The last node points to NULL

A
data pointer

Linked Lists / Slide 9

Array versus Linked Lists

Linked lists have some distinct advantages.

Dynamic: a linked list can easily grow and shrink in size.

We

dont need to know how many nodes will be in the list. They are created in memory as needed. In contrast, the size of a C++ array is fixed at compilation time.

Easy and fast insertions and deletions

To

insert or delete an element in an array, we need to copy to temporary variables to make room for new elements or close the gap caused by deleted elements. With a linked list, no need to move other nodes. Only need to reset some pointers.

Linked Lists / Slide 10

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 11

Pointers

Figure 4.3 (a) declaring pointer variables; (b) pointing to statically allocating memory; (c) assigning a value;
(d) allocating memory dynamically; (e) assigning a value

Linked Lists / Slide 12

Pointers
Figure 4.3
(f) copying a pointer; (g) allocating memory dynamically and assigning a value; (h) assigning NULL to a pointer variable; (i) deallocating memory

Linked Lists / Slide 13

Node of a Link List

A node in a linked struct Node { int item Node *next; }; //end struct
A

list is usually a struct

node is dynamically allocated

Node *p; p = new Node;

Linked Lists / Slide 14

The

head pointer points to the first node in a linked list If head is NULL, the linked list is empty
Executing

the statement the statement head=new Node before head=NULL will result in a lost cell

Linked Lists / Slide 15

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 16

Operations on a Link List

Reference

a node member with the ->

operator
p->item;
A

traverse operation visits each node in the linked list

A pointer variable cur keeps track of the current node

for (Node *cur = head; cur != NULL; cur = cur->next) cout << cur->item << endl;

Linked Lists / Slide 17

Operations on a Link List

Figure 4.9 The effect of the assignment cur = cur->next

Linked Lists / Slide 18

Operations on a Link List

Deleting

an interior node

prev->next=cur->next;

Figure 4.10 Deleting a node from a linked list

Linked Lists / Slide 19

Operations on a Link List

Deleting

the first node

head=head->next;
Return

deleted node to system

cur->next = NULL; delete cur; cur=NULL;

Figure 4.11 Deleting the first node

Linked Lists / Slide 20

Operations on a Link List

To insert a node between two nodes

newPtr->next = cur; prev->next = newPtr;

Figure 4.12 Inserting a new node into a linked list

Linked Lists / Slide 21

Operations on a Link List

To

insert a node at the beginning of a linked

newPtr->next = head; head = newPtr;

list

Figure 4.13 Inserting at the beginning of a linked list

Linked Lists / Slide 22

Operations on a Link List

Inserting

at the end of a linked list is not a special case if cur is NULL

newPtr->next = cur; prev->next = newPtr;

Figure 4.14 Inserting at the end of a linked list

Linked Lists / Slide 23

Operations on a Link List

Determining

the point of insertion or deletion for a sorted linked list of objects

for(prev = NULL, cur= head; (cur != null)&& (newValue > cur->item); prev = cur, cur = cur->next;

Linked Lists / Slide 24

Operations on a Link List

A

function with access to a linked lists head pointer has access to the entire list Pass the head pointer to a function as a reference argument

Figure 4.22 A head pointer as a value argument

Linked Lists / Slide 25

List Overview
Motivation Memory Representation Linked lists

Abstract data type (ADT) Array Vs Link List Pointers Node Representation Insert, find, delete, print, etc. Circular linked lists Doubly linked lists

Implementation of Linked List

Basic operations of linked lists

Variations of linked lists

Linked Lists / Slide 26

Circular Link List

Last

node references the first node Every node has a successor No node in a circular linked list contains NULL

Figure 4.25 A circular linked list

Linked Lists / Slide 27

Doubly linked list

Each

node points to both its predecessor and its successor Circular doubly linked list

precede pointer of the dummy head node points to the last node next reference of the last node points to the dummy head node No special cases for insertions and deletions

Linked Lists / Slide 28

Doubly linked list

Figure 4.29 (a) A circular doubly linked list with a dummy head node (b) An empty list with a dummy head node

Linked Lists / Slide 29

Doubly Linked List

To delete the node to which cur points (cur->precede)->next = cur->next; (cur->next)->precede = cur->precede;
To

insert a new node pointed to by newPtr before the node pointed to by cur
newPtr->next = cur; newPtr->precede = cur->precede; cur->precede = newPtr; newPtr->precede->next = newPtr;

Linked Lists / Slide 30

Thank You

Linked Lists / Slide 31

Linked Lists / Slide 32

A Simple Linked List Class

use two classes: Node and List Declare Node class for the nodes
We

data: double-type data in this example next: a pointer to the next node in the list

class Node { public: double Node* };

data; next;

// data // pointer to next

Linked Lists / Slide 33

A Simple Linked List Class

Declare List, which contains

head: a pointer to the first node in the list. Since the list is empty initially, head is set to NULL Operations on List

class List { public: List(void) { head = NULL; } ~List(void);

// constructor // destructor

bool IsEmpty() { return head == NULL; } Node* InsertNode(int index, double x); int FindNode(double x); int DeleteNode(double x); void DisplayList(void); private: Node* head; };

Linked Lists / Slide 34

A Simple Linked List Class

Operations

of List

IsEmpty: determine whether or not the list is empty InsertNode: insert a new node at a particular position FindNode: find a node with a given value DeleteNode: delete a node with a given value DisplayList: print all the nodes in the list

Linked Lists / Slide 35

Inserting a new node

Node* InsertNode(int index, double x)

Insert a node with data equal to x after the indexth elements.

(i.e., when index = 0, insert the node as the first element; when index = 1, insert the node after the first element, and so on)

If the insertion is successful, return the inserted node. Otherwise, return NULL.
(If index is < 0 or > length of the list, the insertion will fail.)

Steps
1.

Locate indexth element

indexth element

2.
3. 4.

Allocate memory for the new node Point the new node to its successor Point the new nodes predecessor to the new node
newNode

Linked Lists / Slide 36

Inserting a new node

Possible cases of InsertNode

1. 2. 3. 4.

Insert into an empty list Insert in front Insert at back Insert in middle

But, in fact, only need to handle two cases

Insert as the first node (Case 1 and Case 2) Insert in the middle or at the end of the list (Case 3 and Case 4)

Linked Lists / Slide 37

Inserting a new node

Node* List::InsertNode(int index, double x) { if (index < 0) return NULL; int currIndex = 1; Node* currNode = head; while (currNode && index > currIndex) { currNode = currNode->next; currIndex++; } if (index > 0 && currNode == NULL) return NULL; Node* newNode = newNode->data = if (index == 0) { newNode->next head } else { newNode->next currNode->next } return newNode; new x; = = Node;

Try to locate indexth node. If it doesnt exist, return NULL.

head; newNode;

= =

currNode->next; newNode;

Linked Lists / Slide 38

Inserting a new node

Node* List::InsertNode(int index, double x) { if (index < 0) return NULL; int currIndex = 1; Node* currNode = head; while (currNode && index > currIndex) { currNode = currNode->next; currIndex++; } if (index > 0 && currNode == NULL) return NULL; Node* newNode = newNode->data = if (index == 0) { newNode->next head } else { newNode->next currNode->next } return newNode; new x; = = Node;

head; newNode;

Create a new node

= =

currNode->next; newNode;

Linked Lists / Slide 39

Inserting a new node

Node* List::InsertNode(int index, double x) { if (index < 0) return NULL; int currIndex = 1; Node* currNode = head; while (currNode && index > currIndex) { currNode = currNode->next; currIndex++; } if (index > 0 && currNode == NULL) return NULL; Node* newNode = newNode->data = if (index == 0) { newNode->next head } else { newNode->next currNode->next } return newNode; new x; = = Node;

Insert as first element

head

head; newNode;

= =

currNode->next; newNode;

newNode

Linked Lists / Slide 40

Inserting a new node

Node* List::InsertNode(int index, double x) { if (index < 0) return NULL; int currIndex = 1; Node* currNode = head; while (currNode && index > currIndex) { currNode = currNode->next; currIndex++; } if (index > 0 && currNode == NULL) return NULL; Node* newNode = newNode->data = if (index == 0) { newNode->next head } else { newNode->next currNode->next } return newNode; new x; = = Node;

head; newNode;

Insert after currNode

currNode

= =

currNode->next; newNode;

newNode

Linked Lists / Slide 41

Finding a node

int FindNode(double x)

Search for a node with the value equal to x in the list.

If such a node is found, return its position. Otherwise, return 0.

int List::FindNode(double x) { Node* currNode = head; int currIndex = 1; while (currNode && currNode->data != x) { currNode = currNode->next; currIndex++; } if (currNode) return currIndex; return 0; }

Linked Lists / Slide 42

Deleting a node

int DeleteNode(double x) Delete a node with the value equal to x from the list.

If such a node is found, return its position. Otherwise, return 0.

Steps

Find the desirable node (similar to FindNode)

Release the memory occupied by the found node Set the pointer of the predecessor of the found node to the successor of the found node Delete first node Delete the node in middle or at the end of the list

Like InsertNode, there are two special cases

Linked Lists / Slide 43

Deleting a node
int List::DeleteNode(double x) { Try to find the node Node* prevNode = NULL; its value equal to x Node* currNode = head; int currIndex = 1; while (currNode && currNode->data != x) { prevNode = currNode; currNode = currNode->next; currIndex++; } if (currNode) { if (prevNode) { prevNode->next = currNode->next; delete currNode; } else { head = currNode->next; delete currNode; } return currIndex; } return 0; }

with

Linked Lists / Slide 44

Deleting a node
int List::DeleteNode(double x) { Node* prevNode = NULL; Node* currNode = head; int currIndex = 1; while (currNode && currNode->data != x) { prevNode = currNode; currNode = currNode->next; currIndex++; prevNode currNode } if (currNode) { if (prevNode) { prevNode->next = currNode->next; delete currNode; } else { head = currNode->next; delete currNode; } return currIndex; } return 0; }

Linked Lists / Slide 45

Deleting a node
int List::DeleteNode(double x) { Node* prevNode = NULL; Node* currNode = head; int currIndex = 1; while (currNode && currNode->data != x) { prevNode = currNode; currNode = currNode->next; currIndex++; } if (currNode) { if (prevNode) { prevNode->next = currNode->next; delete currNode; } else { head = currNode->next; delete currNode; } return currIndex; } head currNode return 0; }

Linked Lists / Slide 46

Printing all the elements

void

DisplayList(void)

Print the data of all the elements Print the number of the nodes in the list

void List::DisplayList() { int num = 0; Node* currNode = head; while (currNode != NULL){ cout << currNode->data << endl; currNode = currNode->next; num++; } cout << "Number of nodes in the list: " << num << endl; }

Linked Lists / Slide 47

Destroying the list

~List(void)

Use the destructor to release all the memory used by the list. Step through the list and delete each node one by one.

List::~List(void) { Node* currNode = head, *nextNode = NULL; while (currNode != NULL) { nextNode = currNode->next; // destroy the current node delete currNode; currNode = nextNode; } }

Linked Lists / Slide 48

Using List
int main(void) { List list; list.InsertNode(0, 7.0); list.InsertNode(1, 5.0); list.InsertNode(-1, 5.0); list.InsertNode(0, 6.0); list.InsertNode(8, 4.0); // print all the elements list.DisplayList(); if(list.FindNode(5.0) > 0) else if(list.FindNode(4.5) > 0) else list.DeleteNode(7.0); list.DisplayList(); return 0; } // // // // //

6 7 5 Number of nodes in the list: 3 5.0 found 4.5 not found 6 5 Number of nodes in the list: 2

result

successful successful unsuccessful successful unsuccessful

cout cout cout cout

<< << << <<

"5.0 "5.0 "4.5 "4.5

found" << endl; not found" << endl; found" << endl; not found" << endl;

Linked Lists / Slide 49

Variations of Linked Lists

Circular

linked lists

The last node points to the first node of the list

A Head

How do we know when we have finished traversing the list? (Tip: check if the pointer of the current node is equal to the head.)

Linked Lists / Slide 50

Variations of Linked Lists

Doubly

linked lists

Each node points to not only successor but the predecessor There are two NULL: at the first and last nodes in the list Advantage: given a node, it is easy to visit its predecessor. Convenient to traverse lists backwards
A B C

Head