Download presentation

Presentation is loading. Please wait.

Published byChris Crown Modified over 2 years ago

1
Linear Lists – Linked List Representation Computer College

2
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 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 DataLink Node A0A1A2A3 Node first

4
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 5 Head Predecessor of X Node X Success-o r 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 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 7 Node Linking 1.Single linked lists : Each node contains two links - to the previous an d 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
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 mov ement. Contrast this with array. 8

9
9 9 Singly Linked List Let L = (e 1,e 2,…,e n ) – Each element e i 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, e n, has no node to link to and so its link field is NULL. This structure is also called a chain. e1e1 e2e2 e3e3 enen …… 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) obj Returns the information in the current node.

12
12 Insertion To insert a node X between the nod es A and B:.Create a link from X to B..Create a link from A to X,

13
13 Insertion X A B

14
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.next header.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 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 first link data 0 80

22
22 The List ADT Implementation – by Array A 0, A 1, A 2,..., A N-1 Operation:findKth A0A0A0A0 A1A1A1A1 A2A2A2A2 A N-1 A0A0A0A0 A1A1A1A1 A2A2A2A2 O(1) running time return Arr[2];

23
23 The List ADT Implementation – by Array A 0, A 1, A 2,..., A N-1 Operation: deletion A0A0A0A0 A1A1A1A1 A2A2A2A2 A N-1 A0A0A0A0 A1A1A1A1 A2A2A2A2 A0A0A0A0 A2A2A2A2 A3A3A3A3 O(N) running time

24
24 The List ADT Implementation – by Array A 0, A 1, A 2,..., A N-1 Operation: insertion A0A0A0A0 A1A1A1A1 A2A2A2A2 A N-1 A0A0A0A0 A1A1A1A1 A2A2A2A2 A0A0A0A0 A1A1A1A1A A2A2A2A2 A3A3A3A3 A N-2 A N-1 O(N) running time

25
25 The List ADT Implementation A 0, A 1, A 2,..., A N-1 – by Linked List Operation: FindKth a node: 1)element A 3 2)next link next next next next null O(N) running time

26
26 The List ADT Implementation A 0, A 1, A 2,..., A N-1 – by Linked List Operation: deletion O(1) running time

27
27 The List ADT Implementation A 0, A 1, A 2,..., A N-1 – by Linked List Operation: insertion O(1) running time

28
28 The List ADT Implementation A 0, A 1, A 2,..., A N-1 – by doubly linked list

29
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 List (Single) Linked List findKthO(1)O(n) insertO(n)O(1) deleteO(n)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?

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google