Presentation is loading. Please wait.

Presentation is loading. Please wait.

M180: Data Structures & Algorithms in Java Linked Lists – Part 1 Arab Open University 1.

Similar presentations


Presentation on theme: "M180: Data Structures & Algorithms in Java Linked Lists – Part 1 Arab Open University 1."— Presentation transcript:

1 M180: Data Structures & Algorithms in Java Linked Lists – Part 1 Arab Open University 1

2 Outline Linked list nodes Linked list operations –Insertion –Append –Deletion Other types of linked lists –Doubly-linked –Circular

3 Limitation of Arrays An array has a limited number of elements –routines inserting a new value have to check that there is room Can partially solve this problem by reallocating the array as needed (how much memory to add?) –adding one element at a time could be costly –one approach - double the current size of the array A better approach: use a Linked List

4 Dynamically Allocating Elements Allocate elements one at a time as needed, have each element keep track of the next element Result is referred to as linked list of elements, track next element with a pointer

5 5 Anatomy of a linked list A linked list consists of: –A sequence of nodes abcd Each node contains a value and a link (reference) to some other node The last node contains a null link The list may have a header myList

6 6 More terminology A node’s successor is the next node in the sequence –The last node has no successor A node’s predecessor is the previous node in the sequence –The first node has no predecessor A list’s length is the number of elements in it –A list may be empty (contain no elements)

7 ListNode Linked Lists 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 ListNode that contain the data and a reference to the next ListNode 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. A0A1A2A3 first ListNode

8 ListNode: Definition public class ListNode { DataType data; ListNode next; // constructors ListNode(DataType d, ListNode n) { data = d; next = n; } ListNode(DataType d) { this (d, null); } ListNode() { this (null); } }

9 a Linked List: Insertion Insert X immediately after current position a current b c d b c d x

10 Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); a current b tmp

11 Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; a current b tmp

12 Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; a current b tmp x

13 Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; // x ’ s next node is b tmp.next = current.next; // a ’ s next node is x current.next = tmp; a current b tmp x

14 Implementing Insertion: Shorter Version A shorter version: // create a new node tmp = new ListNode (x,current.next); // a ’ s next node is x current.next = tmp; a current b tmp x

15 Implementing Insertion: Shorter Version A shorter version: // create a new node tmp = new ListNode (x,current.next); // a ’ s next node is x current.next = tmp; a current b tmp x

16 Insert X immediately at the end of the list // last refers to the last node in the linked list last.next = new ListNode (); last = last.next;// adjust last last.data = x;// place x in the node last.next = null;// adjust next Most efficient approach last = last.next = new ListNode (x, null); Implementing Append a b c d last a b c X d

17 Implementing Basic Deletion Delete an item immediately after current position Basic deletion is a bypass in the linked list. a b x a b current

18 current.next = current.next.next; Implementing Basic Deletion Need a reference to node prior to the one to be deleted. a b x a b x a b current

19 Iterate Through The Linked List If items are stored in contiguous array: //step through array, outputting each item for (int index = 0; index < a.length; index++) System.out.println (a[index]); If items are stored in a linked list: // step through list, outputting each item for(ListNode p=l.first; p!=null; p=p.next) System.out.println (p.data); A0A1A2A3 first


Download ppt "M180: Data Structures & Algorithms in Java Linked Lists – Part 1 Arab Open University 1."

Similar presentations


Ads by Google