Understanding Linked List Implementations with Algorithms and Classes

1. Chapter 20 Implementing lists : Linked implementations

2. Objectives • After studying this chapter you should understand the following: • the design and structure of linked list implementations; • variations in designs for linked lists, including doubly linked lists; • advantages and disadvantages of linked vs. array-based implementations. • Also, you should be able to: • write algorithms for linked-based structures; • define classes implemented with linked-based structures. NH-Chapter 20

3. Linked implementations • Structure built from collection of nodes that reference each other. • A node • contains reference to a list element, • one or more variables referencing other structure nodes. NH-Chapter 20

4. node A B C D First linked implementation • LinkedList: Each node references node containing next list element. NH-Chapter 20

5. Class Node • Class Node, local to LinkedList, models nodes. • Node structure: • must know an element of the List, • must know the next Node in sequence. • As local class of LinkedList has no methods. NH-Chapter 20

6. Class Node implementation public class LinkedList<Element> extends AbstractList<Element> { … private class Node { private Element element; private Node next; // Create a Node containing specified element. public Node (Element element) { this.element = element; this.next = null; } } // end of class Node } // end of class LinkedList NH-Chapter 20

7. LinkedList implementation • public class LinkedList<Element> extends AbstractList<Element> { • private int size; • private Node first; • // Create an empty LinkedList<Element>. • public LinkedList () { • size = 0; • first = null; • } • … • } NH-Chapter 20

8. An empty linked list NH-Chapter 20

9. Linked list with three entries NH-Chapter 20

10. Method to get the i-th node /** * The i-th node of this LinkedList. * The LinkedList must be non-empty. * require 0 <= i && i < this.size() */ private Node getNode (int i) { Node p = first; int pos = 0; // p is pos-th Node while (pos != i) { p = p.next; pos = pos + 1; } return p; } NH-Chapter 20

11. pos 0 Method to get the i-th node : i == 2 LinkedList size 4 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

12. pos 1 Method to get the i-th node : i == 2 LinkedList size 4 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

13. pos 2 Method to get the i-th node : i == 2 LinkedList size 4 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

14. Implementing LinkedList methods public Element get (int index) { Node p = getNode(index); return p.element; } • Note: method get • uses getNode • get(i) will take i+1 steps to get the element. NH-Chapter 20

15. Method remove(int) • Given an index referencing a node to be removed: • Find previous node referencing it. • Update that node’s next. NH-Chapter 20

16. Method remove(int) • Find previous node. LinkedList Element to be removed size 4 first Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

17. Method remove(int) LinkedList Element to be removed size 4 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

18. LinkedList Element to be removed size 4 first p Node Node Node Node next next next next element É element É element É element É Method remove(int) NH-Chapter 20

19. LinkedList Element to be removed size 4 first p Node Node Node Node next next next next element É element É element É element É Copy Method remove(int) NH-Chapter 20

20. Method remove(int) LinkedList Element to be removed size 4 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

21. Method remove(int) LinkedList Element to be removed size 3 first p Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

22. Method remove(int), special case • Recall getNode requires argument >= 0. • If index is 0, it’s not legal to write Node p = getNode(index-1); • Special case: index 0 removes first linked element. • instance variable first of LinkedList must be modified. NH-Chapter 20

23. Method remove(int) LinkedList size 4 node to be removed first Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

24. Method remove(int) LinkedList size 4 node to be removed first Node Node Node Node next next next next element É element É element É element É copy NH-Chapter 20

25. LinkedList size 4 first Method remove(int) node to be removed Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

26. LinkedList size 3 first Method remove(int) node to be removed Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

27. Implementation of remove(int) public void remove (int index) { if (index == 0) first = first.next; else { Node p = getNode(index-1); p.next = p.next.next; } size = size - 1; } NH-Chapter 20

28. Method add (int, Element) • To add an element at the i-th position • must find the element with index i-1 • special case to consider when i is 0. NH-Chapter 20

29. LinkedList Node size 4 Node Node Node Node Element to add first next next next next next element É element É element É element É element É Method add(int, Element) • Add an element at index 2. • Must find previous node. NH-Chapter 20

30. p LinkedList Node size 4 Node Node Node Node Element to add first next next next next next element É element É element É element É element É Method add(int, Element) NH-Chapter 20

31. p LinkedList Node size 4 Node Node Node Node Element to add first next next next next next element É element É element É element É element É Method add(int, Element) • New node next is p’s next NH-Chapter 20

32. p LinkedList Node size 4 Element to add first next element É Method add(int, Element) • p node next is new node Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

33. p LinkedList Node size 5 Element to add first next element É Method add(int, Element) • LinkedList size is incremented. Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

34. LinkedList Node size 4 Element to add first next element É Method add(int, Element) • add at index 0 Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

35. LinkedList Node size 4 Element to add first next element É Method add(int, Element) • add at index 0 Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

36. LinkedList Node size 5 Element to add first next element É Method add(int, Element) • add at index 0 Node Node Node Node next next next next element É element É element É element É NH-Chapter 20

37. Method add (int, Element) public void add (int index, Element element) { Node newNode = new Node(element); if (index == 0) { newNode.next = first; first = newNode; } else { Node p = getNode(index-1); newNode.next = p.next; p.next = newNode; } size = size + 1; } NH-Chapter 20

38. Linked list variations • Adding a reference to last node makes adding to end of list constant. NH-Chapter 20

39. LinkedList: adding a last reference • Creates special cases in other methods. For instance, remove public void remove (int index) { if (size == 1) { // remove only element first = null; last = null; }else if (index == 0) {//remove first element first = first.next; }else { Node p = getNode(index-1); p.next = p.next.next; if (index == size-1) //last element removed last = p; } size = size - 1; } NH-Chapter 20

40. Header nodes • “dummy” node • Always present at front of list, • contains no element, • first always references header node, • first is never null. • Reduces special cases in the implementation of some methods. NH-Chapter 20

41. Header nodes NH-Chapter 20

42. Circular lists • Last node references the first. NH-Chapter 20

43. Doubly-linked lists NH-Chapter 20

44. Doubly-linked list constructor • Assuming Header extends NodeDoublyLinkedList constructor creates header Node, and links it to itself. public DoublyLinkedList () { size = 0; header = new Header(); header.next = header; header.previous = header; } NH-Chapter 20

45. Doubly-linked list constructor NH-Chapter 20

46. Doubly-linked lists: add(Element) Header A B C New NH-Chapter 20

47. Doubly-linked lists: add(Element) • new node previous is node C Header A B C New NH-Chapter 20

48. Doubly-linked lists: add(Element) • new node next is header Header A B C New NH-Chapter 20

49. Doubly-linked lists: add(Element) • Header previous is new node Header A B C New NH-Chapter 20

50. Doubly-linked lists: add(Element) • C node next is new node Header A B C New NH-Chapter 20