Linear Lists – Linked List Representation

Computer College

2

Outlines

Linked list nodes Linked list operations

– Insertion– Deletion

Linked list representation & implementation Other types of linked lists

– Sorted– Doubly-linked– Circular

2

3 3

Single Linked List Definition: A linked list is a collection of nodes that

together form a linear ordering. Each node is a compound object that stores an element and a reference, called next, to another node.

Structure of a node Data Link

Node

A0 A1 A2 A3

Node NodeNodefirst

4 4

Characteristics

Insert and delete nodes in any order The nodes are connected Each node has two components

– Information (data)

– Link to the next node The nodes are accessed through the links

between them

5 5

Head Predecessor of X

Node X

Success-or of X

tail

For each node the node that is in front of it is called predecessor.

The node that is after it is called successor.

6 6

Terminology

Head (front, first node): – The node without predecessor, the node

that starts the lists. Tail (end, last node):

– The node that has no successor, the last node in the list.

Current node: The node being processed. – From the current node we can access the next

node. Empty list: No nodes exist

7 7

Node Linking

1. Single linked lists : Each node contains two links - to the previous and to the next node

2. Double linked lists : Each node contains a link only to the next node

3. Circular lists:The tail is linked to the head.

8

Single linked List Properties

Stores a collection of items non-contiguously. Each item in the list is stored with an indication of

where the next item is. Must know where first item is. The list will be a chain of objects, called nodes, of

type Node that contain the data and a reference to the next Node in the list.

Allows addition or deletion of items in the middle of collection with only a constant amount of data movement. Contrast this with array.

8

9 9

Singly Linked List

Let L = (e1,e2,…,en)– Each element ei is represented in a separate node– Each node has exactly one link field that is used to

locate the next element in the linear list– The last node, en, has no node to link to and so its link

field is NULL. This structure is also called a chain.

e1 e2 e3 en

……

first

Link Field

Data Field

10 10

Class ‘ChainNode’

public class Node

{

Object data;

Node next;

Node(Object obj, Node element)

{

data = obj;

next = element;

}

}

11 11

Operations in ADT Notation

Insert(L,obj)Inserts a node with information e before the current position

Delete(L)Deletes the current node in L , the

current position indicates the next node.

RetrieveInfo(L) objReturns the information in the current node.

12 12

Insertion

Insertion

To insert a node X between the nodes A and B:

.Create a link from X to B.

.Create a link from A to X,

13 13

Insertion

X

A B

14

Adding an element at the beginning

Create a new node;Element in the node has the same value as the new element;Node pointer points to the first element (non-header)Pointer from the header points to new node;

Create(newnode);newnode.next header.next.nextheader.next newnode;

O(1);

15 15

Code Fragment to insert at a head

public void inserthead(Object obj)

{

Node newNode = new Node(obj); // make new Node

newNode.next = head; // newNode --> old head

head = newNode; // head --> newNode

} The time

complexity O(1)

16 16

Deletion

Deletion

To delete a node X between A and B:

• Create a link from A to B,

• Remove node X

17 17

Code Fragment to delete first node

public Node deleteHead() // delete head item

{ // (assumes list not empty)

Node temp = head; // save reference to link

head = head.next; / delete it: head-->old next

return temp; // return deleted link

}

The time complexity O(1)

18 18

Code Fragment to insert at a tail

public void insertLast(Object obj)

{

Node newNode = new Node(obj); // make new link

if( isEmpty() ) // if empty list,

head = newNode; // first --> newNode

else

tail.next = newNode; // old tail --> newNode

tail = newNode; // newNode <-- tail

}

The time complexity O(1)

19 19

Traversal

public int countNodes()

{

int count = 0;

Element e = head;

while(e != null)

{

count++;

e = e.next;

}

return count;

}

A method that computes the number of elements in any list:

20 20

Code Fragment to delete at a tail

public Node deleteTail( ) // delete link with given key

{

Node current = head; // search for link

Node previous = head;

while(current.next != null)

{

if(current.next == null)

return null; // didn't find it

else

{

previous = current; // go to next link

current = current.next;

}

} // found it

if(current == head) // if first link,

head= head.next; // change first

Else // otherwise,

previous.next = current.next; // bypass it

return current;

}

The time complexity O(1)

21 21

Delete any Node

To delete the fourth element from the chain, we – locate the third and fourth nodes– link the third node to the fifth– free the fourth node so that it becomes available for

reuse

20 10 30 11

first

link

data

0

80

22

The List ADT

Implementation

– by Array

A0, A1, A2, ..., AN-1

Operation:findKth

AA00 AA11 AA22 AAN-1N-1

AA00 AA11 AA22 AAN-1N-1

O(1) running time

return Arr[2];

23

The List ADT

Implementation

– by Array

A0, A1, A2, ..., AN-1

Operation: deletion

AA00 AA11 AA22 AAN-1N-1

AA00 AA11 AA22 AAN-1N-1

AA00 AA22 AA33 AAN-1N-1

O(N) running time

24

The List ADT

Implementation

– by Array

A0, A1, A2, ..., AN-1

Operation: insertion

AA00 AA11 AA22 AAN-1N-1

AA00 AA11 AA22 AAN-1N-1

AA00 AA11 A’A’ AA22 AA33 AAN-2N-2 AAN-1N-1

O(N) running time

25

The List ADT

Implementation

A0, A1, A2, ..., AN-1

– by Linked List

Operation: FindKth

a node:

1) element A3

2) next link

next next next next null

O(N) running time

26

The List ADT

Implementation

A0, A1, A2, ..., AN-1

– by Linked List

Operation: deletion O(1) running time

27

The List ADT

Implementation

A0, A1, A2, ..., AN-1

– by Linked List

Operation: insertion O(1) running time

28

The List ADT

Implementation

A0, A1, A2, ..., AN-1

– by doubly linked list

29

The List ADT

Summary– running time coomparion

– when to use Array list or Linked list? Array list: numerous findKth operations + seldom delete/insert operations Linked list: numerous delete/insert operations + seldom findKth operations

Array ListArray List (Single) Linked List(Single) Linked List

findKthfindKth O(1)O(1) O(n)O(n)

insertinsert O(n)O(n) O(1)O(1)

deletedelete O(n)O(n) O(1)O(1)

30 30

Circular List Representation

Programs that use chains can be simplified or run faster by doing one or both of the following:

1. Represent the linear list as a singly linked circular list (or simply circular list) rather than as a chain

2. Add an additional node, called the head node, at the front

31 31

Circular List Representation

32 32

Doubly Linked List Representation

An ordered sequence of nodes in which each node has two pointers: left and right.

33 33

Class ‘DoubleNode’

public class Node

{

Public String element;

Public Node prev;

Public Node next;

Public Node(Object obj, Node p, Node n)

{

Element=obj;

Prev=p;

Next=n;

}

34 34

Circular Doubly Linked List

Add a head node at the left and/or right ends In a non-empty circular doubly linked list:

– LeftEnd->left is a pointer to the right-most node (i.e., it equals RightEnd)

– RightEnd->right is a pointer to the left-most node (i.e., it equals LeftEnd)

Can you draw a circular doubly linked list with a head at the left end only by modifying Figure 6.7?