List processing algorithms

  • Recall that:

    • The program uses the first (or head) variable to reference to the first node of a linked list

      Therefore:

      • Only the first node is immediately accessible by a program...

  • Processing data stored in a linked list (a.k.a. list processing) often requires:

    • visiting all elements in the linked list by traversing the chain

    Graphically:

The standard list traversal algorithm

  • Warning: you must never use the variable first to traverse the linked list:
      

       // The standard list traversal algorithm

   Node p;

   p = first;

   while ( p != null )
   {
       // Process data in node p

       p = p.next;
   }

The standard list traversal algorithm

  • Define a helper reference variable p to traverse the linked list:
      

       // The standard list traversal algorithm

   Node p;

   p = first;

   while ( p != null )
   {
       // Process data in node p

       p = p.next;
   }

The standard list traversal algorithm

  • Initialize the helper reference variable p to point the first node of the linked list: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Process data in node p

       p = p.next;
   }

The standard list traversal algorithm

  • When p is pointing at a certain node, we can access its data as p.item:
      

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Process data (p.item) in node p

       Notice:  p.next is the address of the next Node !
   }

The standard list traversal algorithm

  • After processing a node, we advance p to point to the next node with the statement   p = p.next: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Process data (p.item) in node p

       p = p.next; // Advances p to next node
   }

The standard list traversal algorithm

  • Insight: the reason why the variable p "advances" to the next node is because
    p = p.next assigns the address in p.next to the variable p: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Process data (p.item) in node p

       p = p.next; // Advances p to next node
   }

The standard list traversal algorithm

  • We repeat the steps until we have process the data in the last node, then p will contain null: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Process data (p.item) in node p

       p = p.next; // Advances p to next node
   }

Animation of the standard list traversal algorithm

  • The helper variable p is often called current (because it points to the current node that is being processed):

    The list traversal algorithm: 

       Node current = first;

   while ( current != null ) // Find last list element
   {
       // Process current node here

       current = current.next;  // Move to next node
   }

Use the list traversal algorithm to print out all items in a list

  • Problem:

    • Print out all the item values stored in a linked list

  • The list traversal algorithm will visit every node p: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       // Visiting node p (p.item = data store in p)

       p = p.next; // Advances p to next node
   }

     

Use the list traversal algorithm to print out all items in a list

  • Problem:

    • Print out all the item values stored in a linked list

  • To print out all data item stored in a linked list: 

       // The standard list traversal algorithm

   Node p;

   p = first;   // P now points to the first node

   while ( p != null )
   {
       System.out.println( p.item );

       p = p.next; // Advances p to next node
   }

    Print out the value in item using p.item during the list traversal...

DEMO: demo/11-linked-list/01-create/Demo.java

Enhancements of the list traversal algorithm

  • The list traversal algorithm is the basis for many other list processing algorithms.

    Example:

    • Find a node in the list that contains a special value (say: X).

  • Here is the basic list traversal algorithm: 

       Node current = first;

   while ( current != null )
   {
       // Process current node here


       current = current.next;  // Move to next node
   }

Enhancements of the list traversal algorithm

  • The list traversal algorithm is the basis for many other list processing algorithms.

    Example:

    • Find a node in the list that contains a special value (say: X).

  • To find a node that contains X, we exit the loop when the current contains the X: 

       Node current = first;

   while ( current != null ) // Find list element containing X
   {
       if ( current (node) contains X )
           break;

       current = current.next;  // Move to next node
   }

   // Here:
   //    either current == null (no node contains X)
   //    or the current (node) contains X

Enhancements of the list traversal algorithm

  • The list traversal algorithm is the basis for many other list processing algorithms.

    Example:

    • Find a node in the list that contains a special value (say: X).

  • The search adaptation of the list traversal is often written as follows: 

       Node current = first;

   while ( current != null && !(current (node) contains X) ) 
   {
    
          

       current = current.next;  // Move to next node
   }

   // Here:
   //    either current == null (no node contains X)
   //    or the current (node) contains X

Use the list traversal algorithm to find a list element that contains a certain key

  • Problem:

    • Write a method that returns a list element that contains a certain value

  • The method findNode(f, s) finds a node in linked list f that contains the value s: 

       public static Node findNode( Node f, String s )
   {
       Node p = first;

       while ( p != null )
       {
           // Visiting node p (p.item = data store in p)


           p = p.next; // Advances p to next node
       }

       return null;
   }

Use the list traversal algorithm to find a list element that contains a certain key

  • Problem:

    • Write a method that returns a list element that contains a certain value

  • We test every node by (1) visit the node (using the variable p): 

       public static Node findNode( Node f, String s )
   {
       Node p = f;            // Start at the first node f

       while ( p != null )    // Visit every node in list f
       {
           // Visiting node p (p.item = data store in p)


           p = p.next; // Advances p to next node
       }

       return null;
   }

Use the list traversal algorithm to find a list element that contains a certain key

  • Problem:

    • Write a method that returns a list element that contains a certain value

  • (2) If node p contains the search value, we return p: 

       public static Node findNode( Node f, String s )
   {
       Node p = f;            // Start at the first node f

       while ( p != null )    // Visit every node in list f
       {
           if ( p.item.equals( s ) )
               return p;      // Found s --> return p

           p = p.next; // Advances p to next node
       }

       ???
   }

Use the list traversal algorithm to find a list element that contains a certain key

  • Problem:

    • Write a method that returns a list element that contains a certain value

  • (3) If we exit the loop, then s is not found in the linked list f --- we return null: 

       public static Node findNode( Node f, String s )
   {
       Node p = f;            // Start at the first node f

       while ( p != null )    // Visit every node in list f
       {
           if ( p.item.equals( s ) )
               return p;      // Found s --> return p

           p = p.next; // Advances p to next node
       }

       return null;           // Not found
   }

DEMO: demo/11-linked-list/01-create/Demo2.java

Postscript: list traversal using a for-loop

  • Print out item in linked lis using a while-loop: 

       Node p = first;   // P now points to the first node

   while ( p != null )
   {
       System.out.println( p.item );
       p = p.next; // Advances p to next node
   }

  • This while-loop can be re-written as a for-loop as follows: 

    
   for ( Node p = first; p != null; p = p.next; )
   {
       System.out.println( p.item );
   }

    (Personally, I prefer to use a while-loop because it's more flexbible...)

DEMO: demo/11-linked-list/01-create/Demo3.java