Download presentation

1
**M180: Data Structures & Algorithms in Java**

Linked Lists – Part 1 Arab Open University

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
**Anatomy of a linked list**

A linked list consists of: A sequence of nodes myList a b c d 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

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
**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. con•tig•u•ous adj. 1 in physical contact; touching along all or most of one side 2 near, next, or adjacent SYN. adjacent ListNode ListNode ListNode ListNode first A0 A1 A2 A3

8
**ListNode: Definition public class ListNode <DataType> {**

DataType data; ListNode<DataType> next; // constructors ListNode(DataType d, ListNode<DataType> n) data = d; next = n; } ListNode(DataType d) { this (d, null); } ListNode() { this (null); }

9
**Linked List: Insertion**

a b c d current Insert X immediately after current position a b c d x current

10
**Implementing Insertion: Step By Step**

Insertion immediately after current position // create a new node tmp = new ListNode<DataType>(); a b current tmp

11
**Implementing Insertion: Step By Step**

Insertion immediately after current position // create a new node tmp = new ListNode<DataType>(); // place x in the element field tmp.data = x; a b current tmp

12
**Implementing Insertion: Step By Step**

Insertion immediately after current position // create a new node tmp = new ListNode<DataType>(); // place x in the element field tmp.data = x; a b x current tmp

13
**Implementing Insertion: Step By Step**

Insertion immediately after current position // create a new node tmp = new ListNode<DataType>(); // 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 b x current tmp

14
**Implementing Insertion: Shorter Version**

A shorter version: // create a new node tmp = new ListNode<DataType>(x,current.next); // a’s next node is x current.next = tmp; a b x current tmp

15
**Implementing Insertion: Shorter Version**

A shorter version: // create a new node tmp = new ListNode<DataType>(x,current.next); // a’s next node is x current.next = tmp; a b x current tmp

16
**Implementing Append Insert X immediately at the end of the list**

// last refers to the last node in the linked list last.next = new ListNode<DataType>(); 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); a b c d last a b c d X last

17
**Implementing Basic Deletion**

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

18
**Implementing Basic Deletion**

Need a reference to node prior to the one to be deleted. current.next = current.next.next; a x b current a x b current 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); A0 A1 A2 A3 first

Similar presentations

© 2021 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