CSCI 162 - Lecture 6 - Linked Lists

Instructor's Class Notes

 

1. Linked Lists - A sequence of elements arranged one after another, with each element connected to the next element by a "link."
• node - A component that includes the element along with its link to next element is called a node, used in a linked list like as follows:
  
  
• node class - A simple node for holding integers:
  

  
  public class IntNode
  {
      private int data;       // The element stored in this node
      private IntNode link;   // Refers to the next node in the list
      ...         
                  

• Head nodes, Tail nodes - For a program to use a linked list of nodes it must access the linked list through a Head Node, or a Tail node (or it could use both) as in the following
  
  
• Null Reference - Instead of (and sometimes in addition to) a Tail node it is common to use a Null Reference so that the last element in the list has it's next element reference set to null.
• Example:
  
• Empty List - The empty list (with no elements) is signified by a Head node that is set to null.
• IntNode.java - Source is here.
  
• IntNode.java - Documentation is here.
  
  Common Operations:
  • Adding a new node (at the head) - head = new IntNode(newData, head);
  • Removing a node (from the head) - head = head.getLink();
  • Adding a node (not at the head) - Suppose selection is a reference to a node of a linked list.
    

    Activating the following method adds a new node after the selected node (using element as the new data):

    
                selection.addNodeAfter(element);
                               

    The implementation of addNodeAfter needs only one statement to accomplish its work:

    
                link = new IntNode(element, link);
                            

  • Removing a node (not at the head) - Suppose selection is a reference to a node of a linked list.
    

    Activating the following method removes the node after the selected node:

    
                selection.removeNodeAfter( );
                               

    The implementation of removeNodeAfter needs only one statement to accomplish its work:

    
                link = link.link;
                               

• IntNodeTest.java - JUnit Tests are here.
• Complex Operations
  • Traversing a Linked List - Traversing a linked list made from the traditional node object is rather straightfoward:
    

    
        public static int listLength(IntNode head)
        {
            IntNode cursor;
            int answer;
            
            answer = 0;
            for (cursor = head; cursor != null; cursor = cursor.link)
                answer++;
                
            return answer;
        }                        
                            

  • Searching for a Target in a Linked List - Uses the same traversal code with a conditional:
    

    
        public static IntNode listSearch(IntNode head, int target)
        {
             IntNode cursor;
             
             for (cursor = head; cursor != null; cursor = cursor.link)
                if (target == cursor.data)
                   return cursor;
                   
             return null;
         }                  

  • Get a Node at a Particular Position - Uses the same traversal code but with a counter:
    

    
        public static IntNode listPosition(IntNode head, int position)
        {
            IntNode cursor;
            int i;
    
            if (position <= 0)
                throw new IllegalArgumentException("position is not positive.");
    
            cursor = head;
            for (i = 1; (i < position) && (cursor != null); i++)
                cursor = cursor.link;
    
            return cursor;
        }
                            

  • Copying a List - Uses the same traversal code but with a counter:
    

    
        public static IntNode[ ] listCopyWithTail(IntNode source)
        {
            // Notice that the return value is an array of two IntNode components.
            // The [0] component is the head reference for the new list and
            // the [1] component is the tail reference for the new list.
            // Also notice that the answer array is automatically initialized to contain
            // two null values. Arrays with components that are references are always
            // initialized this way.
            IntNode copyHead;
            IntNode copyTail;
            IntNode[ ] answer = new IntNode[2];
            
            // Handle the special case of an empty list.
            if (source == null)
                return answer; // The answer has two null references.
                
            // Make the first node for the newly created list.
            copyHead = new IntNode(source.data, null);
            copyTail = copyHead;
            
            // Make the rest of the nodes for the newly created list.
            while (source.link != null)
            {
                source = source.link;
                copyTail.addNodeAfter(source.data);
                copyTail = copyTail.link;
            }
            
            // Return the head and tail references for the new list.
            answer[0] = copyHead;
            answer[1] = copyTail;
            return answer;
        }
                            

• Important - Following are important things to understand regarding ADTs and Linked Lists:
  • The Basics - A linked list consists of nodes; each node contains some data and a link to the next node in the list. The link part of the final node contains the null reference.
  • More Advanced - Typically, a linked list is accessed through a head reference that refers to the head node (i.e., the first node). Sometimes a linked list is accessed elsewhere, such as through the tail reference that refers to the last node.
  • Perfect for ADTs - Linked lists can be used to implement ADTs. Such an ADT will have one or more private instance variables that are references to nodes in a linked list. The methods of the ADT will use the node methods to manip- ulate the linked list.
  • Two Difference Ways - ADTs often can be implemented in many different ways, such as with an array or with a linked list. In general, arrays are better at random access; linked lists are better at additions/removals at a cursor.
  • Doubly Linked Lists - A doubly linked list has nodes with two references: one to the next node and one to the previous node. Doubly linked lists are a good choice for supporting a cursor that moves forward and backward.
  • Dummies - Including dummy head and tail nodes on a linked list will simplify the programming for insertion and removal of nodes.
  • Java has Classes - The Java Class Libraries include sequence classes based on arrays (ArrayList) and based on linked lists (LinkedList).