linklisr
- 1. Linked Lists An Alternative Collections Data Structure What Is A Linked List? A data structure using memory that expands and shrinks as needed Relies on identical nodes “pointing” or “linked” to other nodes Each node is an instance of a class (i.e. an object) Head Example Declarations public class IntNode { private int data; private IntNode link; … } OR public class Part { private int partNo; private double price; private Part link; … }
- 2. Special Nodes Head node The first node in a linked list Almost all programs using linked lists will maintain a pointer to the head node An empty list is represented by storing Null in the head variable Tail node The last node in a linked list Many programs maintain a pointer to the tail node A tail node points to a “null” reference In an empty list tail will also be Null Necessary Methods Methods to access and modify data: e.g. getData(), getLink(), setData(int newData), setLink(??? newLink) Methods for creating nodes i.e. constructors Methods for adding and removing nodes Caution! Always make sure that your linked list methods work correctly with an empty list.
- 3. Adding a Node to the Front of a List 1. Create a new node with the desired data, and the link pointing to the current head node 2. Make the “head” pointer point to the new node What happens if we started with an empty list? remove Head Removing the First Node of a List Make the head pointer point to what the current head node is pointing to What happens to the original head node? What if there was only one node in the list? remove Head Adding a Node After a Selected Node 1. Create a new node pointing to whatever the selected node is currently pointing to 2. Make the selected node point to the new node What happens if the selected node was the last node in the list? remove Head Selected
- 4. Removing a Selected Node Head Selected Can we remove this? Removing the Node After a Selected Node Head Selected Can we remove this? Desired Result: Head Selected What happens if we removed the tail node? Manipulating Entire Linked Lists Traverse the entire list in a loop that terminates when the null pointer is reached In the body of the loop perform the necessary operation(s)
- 5. Manipulating Entire Linked Lists Examples: count the elements of the list Print the elements of the list Update the values in the list (e.g. increase all prices by 10%) If implemented in the same class as the node (i.e. no separate list class), it is better to use static methods, this way the method can be used for empty lists Sample Code IntNode current; for (current = head; current != null; current = current.link) { … } Or: IntNode current; current = head; while (current != null) { … current = current.link; } Copying an Entire List public static IntNode copyList (IntNode head) { if (head == null) return null; IntNode copyHead = new IntNode (head.data,null); IntNode copyTail = copyHead; IntNode source = head; while (source.link != null) { source = source.link; copyTail.addNodeAfter(source.data); copyTail = copyTail.link; } return copyHead; }
- 6. Copying a Part of a List Given a start node and an end node make a copy of that part of the list Can we return both the head and tail of the copy? How does the method work? Is it that much different from copying the full list? Linked List Application – IntLinkedBag Keeps track of integer elements Can add or delete elements Answers questions about its elements Can add all the contents of another bag Grows and shrinks in size as needed IntLinkedBag - Methods public void add (int element) public void addAll (IntLinkedBag addend) public int countOccurences(int target) public boolean remove (int target) public int size() public void trimToSize() public static IntLinkedBag union (IntLinkedBag b1, IntLinkedBag b2) public int grab() public void ensureCapacity (int minimumCapacity) ??? public int getCapacity() ???
- 7. Another Linked List Application - DoubleLinkedSeq Similar to bag but sequence is preserved An additional instance variable is needed to hold the position of the “current” element Two additional instance variables “tail” and “precursor” may be used for convenience Some methods can be preserved, others must be modified Additional methods are needed Implementation: assignment 5 Doubly Linked Lists Similar to linked lists with pointers in both directions Head Tail Array vs. Linked Lists vs. Doubly Linked Lists Which is better for the following operations?: Random access Frequent additions/removals in the middle of a sequence Frequent forward and backward searching of a sequence Frequent size changes