Module 6: Sets and lists

public class OurListUsingArrays {

    // This is the array in which we'll store strings.
    String[] strings = new String [100];;

    // Initially, there are none.
    int numStrings = 0;


    public void add (String s)
    {
	if (numStrings < 100) {
	    strings[numStrings] = s;
	    numStrings ++;
	}
    }


    public int size ()
    {
	return numStrings;
    }


    public String get (int i)
    {
	return strings[i];
    }


    public boolean contains (String s)
    {
	// Note: we need to use numStrings instead of strings.length
	for (int i=0; i < numStrings; i++) {
	    if ( strings[i].equalsIgnoreCase(s) ) {
		return true;
	    }
	}
	return false;
    }

}

To see how a linked list works, we'll first examine this piece of code:

// We'll use instances of this object in main() below.

class ListItem {

    String data;    
    ListItem next;

}


public class StrangeExample {

    public static void main (String[] argv)
    {
	// Make one instance and put a string in the data field.
	ListItem first = new ListItem();
	first.data = "Yes minister";

	// Make a second one.
	ListItem second = new ListItem();
	second.data = "Seinfeld";

	// Now link them: make the first one point to the second.
	first.next = second;

	// Make a third and make the second point to the third.
	ListItem third = new ListItem();
	third.data = "Cheers";
	second.next = third;

	// Make a fourth etc.
	ListItem fourth = new ListItem();
	fourth.data = "Frasier";
	third.next = fourth;

	ListItem last = new ListItem();
	last.data = "Simpsons";
	fourth.next = last;

	// Now print. Note the extensive use of the dot-operator.
	System.out.println ("First: " + first.data);
	System.out.println ("Second: " + first.next.data);
	System.out.println ("Third: " + first.next.next.data);
	System.out.println ("Fourth: " + first.next.next.next.data);
	System.out.println ("Last: " + first.next.next.next.next.data);
	System.out.println ("Last (alt): " + last.data);
    }

}

In-Class Exercise 6: Draw the memory picture after each new ListItem has been created.

Instead of using the dot-operator in sequence, we'll use a different approach:

• We will track the last item in the list using a pointer.

• When a new item is to be added, we add that to the end
       ⇒ We'll use the "last" pointer.

class ListItem {

    String data;    
    ListItem next;

}


public class StrangeExample2 {

    public static void main (String[] argv)
    {
	// Make one instance and put a string in the data field.
	ListItem first = new ListItem();
	first.data = "Yes minister";
        
        // This is also the last one, right now.
        ListItem last = first;

	// Make a second one.
	ListItem nextOne = new ListItem();
	nextOne.data = "Seinfeld";

	// Now link them: make the first one point to the second.
	last.next = nextOne;

        // Advance the "last" pointer.
        last = nextOne;

	// Make a third and make the second point to the third.
	nextOne = new ListItem();
	nextOne.data = "Cheers";
	last.next = nextOne;
        last = nextOne;


	// Make a fourth etc.
	nextOne = new ListItem();
	nextOne.data = "Frasier";
	last.next = nextOne;
        last = nextOne;

        // Last one.
	nextOne = new ListItem();
	nextOne.data = "Simpsons";
	last.next = nextOne;
        last = nextOne;


	// Now print by repeatedly advancing the pointer.
        ListItem listPointer = first;
	System.out.println ("First: " + listPointer.data);

        listPointer = listPointer.next;
	System.out.println ("Second: " + listPointer.data);

        listPointer = listPointer.next;
	System.out.println ("Third: " + listPointer.data);

        listPointer = listPointer.next;
	System.out.println ("Fourth: " + listPointer.data);

        listPointer = listPointer.next;
	System.out.println ("Last: " + listPointer.data);
    }

}

• It's easier to first understand the printing:
  • Notice how the pointer variable listPointer starts by pointing to the same thing that first is pointing to?
  • Then observe that listPointer advances along to the second item, then the third etc.

• Similarly, earlier in the program, the nextOne variable (a pointer, since it's an object variable) is made to point to a new object instance each time.

• Each time a new item is added to the end, the last pointer is advanced along to point to the last one.

The repetition in printing suggests a loop:

class ListItem {

    String data;    
    ListItem next;

}


public class StrangeExample3 {

    public static void main (String[] argv)
    {
	// Make one instance and put a string in the data field.
	ListItem first = new ListItem();
	first.data = "Yes minister";
        ListItem last = first;

	// Make a second one.
	ListItem nextOne = new ListItem();
	nextOne.data = "Seinfeld";
	last.next = nextOne;
        last = nextOne;

	// Make a third and make the second point to the third.
	nextOne = new ListItem();
	nextOne.data = "Cheers";
	last.next = nextOne;
        last = nextOne;


	// Make a fourth etc.
	nextOne = new ListItem();
	nextOne.data = "Frasier";
	last.next = nextOne;
        last = nextOne;

        // Last one.
	nextOne = new ListItem();
	nextOne.data = "Simpsons";
	last.next = nextOne;
        last = nextOne;


	// Now print by repeatedly advancing the pointer - in a simple loop.
        ListItem listPointer = first;
        while (listPointer != null) {
            System.out.println (listPointer.data);
            listPointer = listPointer.next;
        }
    }

}

• Once again, the variable listPointer now moves along the list, at each step pointing at the next item in the list.

• Notice the loop termination condition:

          while (listPointer != null) {
              // ...
          }
      

  • When the last item is added, its .next field contains null (because it points to nothing).
  • Thus, we know we've reached the end when we're pointing to null.

In-Class Exercise 7: Download StrangeExample3.java and add the line

  System.out.println (listPointer);
  

Can the code for adding new items also be compacted?
     ⇒ Yes, indeed:

class ListItem {

    String data;    
    ListItem next;

}


public class StrangeExample4 {

    static ListItem first = null;
    static ListItem last = null;

    public static void main (String[] argv)
    {
	// Make one instance and put a string in the data field.
	first = new ListItem();
	first.data = "Yes minister";
        last = first;

	// Add the rest.
        add ("Seinfeld");
        add ("Cheers");
        add ("Frasier");
        add ("Simpsons");

	// Now print by repeatedly advancing the pointer - in a simple loop.
        ListItem listPointer = first;
        while (listPointer != null) {
            System.out.println (listPointer.data);
            listPointer = listPointer.next;
        }
    }


    static void add (String s)
    {
        // Make a new instance (new list node) and add the data.
	ListItem nextOne = new ListItem();
	nextOne.data = s;

        // Make the current last one point to the new one.
	last.next = nextOne;

        // Adjust the last pointer.
        last = nextOne;
    }
    

}

We're now in position to create our own linked-list:

• We will put all the code in a class called ListWithLinks (to resemble Java's LinkedList class).

• We will name the methods add(), size(), get() and contains().

class ListItem {

    String data;
    ListItem next;

}


public class ListWithLinks {

    // Instance variables.
    ListItem front = null;
    ListItem rear = null;

    // To keep track of the size.
    int numItems = 0;


    public void add (String s)
    {
	if (front == null) {
            // The special case of an empty list needs to be handled differently.
	    front = new ListItem ();
	    front.data = s;
	    rear = front;
	    rear.next = null;
	}
	else {
            // Just like before:
            ListItem nextOne = new ListItem ();
	    nextOne.data = s;
	    rear.next = nextOne;
	    rear = nextOne;
	}    

	numItems ++;
    }


    public int size ()
    {
	return numItems;
    }

    
    public String get (int i)
    {
        // Sanity check:
	if (i >= numItems) {
	    return null;
	}

        // Otherwise, count up to the i-th item.
	int count = 0;
	ListItem listPtr = front;

	while (count < i) {
	    listPtr = listPtr.next;
	    count ++;
	}

	return listPtr.data;
    }


    public boolean contains (String s)
    {
        // Sanity check.
	if (front == null) {
	    return false;
	}

        // Start from the front and walk down the list. If it's there,
        // we'll be able to return true from inside the loop.
	ListItem listPtr = front;
	while (listPtr != null) {
	    if ( listPtr.data.equals(s) ) {
		return true;
	    }
	    listPtr = listPtr.next;
	}
	return false;
    }

}

This class itself will be used in "main" (or elsewhere) as a data structure:

public class ListWithLinksExample {

    public static void main (String[] argv)
    {
	ListWithLinks favoriteShows1 = new ListWithLinks();
	favoriteShows1.add ("Yes minister");
	favoriteShows1.add ("Seinfeld");
	favoriteShows1.add ("Cheers");
	favoriteShows1.add ("Frasier");
	favoriteShows1.add ("Simpsons");

	ListWithLinks favoriteShows2 = new ListWithLinks();
	favoriteShows2.add ("Mad about you");
	favoriteShows2.add ("Seinfeld");
	favoriteShows2.add ("Frasier");
	favoriteShows2.add ("Cosby");

	computeIntersection (favoriteShows1, favoriteShows2);
    }


    static void computeIntersection (ListWithLinks listA, ListWithLinks listB)
    {
	System.out.println ("Intersection:");
	for (int i=0; i < listA.size(); i++) {    // Calls the size() method in ListWithLinks
	    String s = listA.get(i);              // Calls the get() method
	    if ( listB.contains(s) ) {            // The contains() method
		System.out.println ("  " + s);
	    }
	}
    }

}

• Some nomenclature: each individual ListItem instance in the list is called a node of the list.

• We've changed the names first and last to the more traditional names of front and rear.

In-Class Exercise 8: Download ListWithLinks2.java and ListWithLinksExample2.java and implement the printList() method in ListWithLinks2 to print out the list. The code in ListWithLinksExample2 calls this method.

Conceptual view of a linked-list:

• A simple conceptual view:

  

• With a little more detail (actual addresses):

  

• Suppose this were a list of integers, containing the first four odd numbers:

  

  • Notice that the view is conceptual: the actual addresses do not necessarily correspond to visual order.
  • "front" and "rear" are variables that may be in other objects.

• If we were to add the data "9" to this list:

  

Some enhancements

We will add a couple more methods ("features") to our list:

• A toString() method.

• A way to print the list with memory addresses of the nodes.

• We'll change the name of the class to the more traditional OurLinkedList, but different from Java's LinkedList class.

class ListItem {

    // ... 

}


public class OurLinkedList {

    // ... same as before ...

    public void add (String s)
    {
        // ...
    }


    public int size ()
    {
        // ...

    }

    
    public String get (int i)
    {
        // ...
    }


    public boolean contains (String s)
    {
        // ...
    }


    public String toString ()
    {
	if (front == null) {
	    return "empty";
	}

        // Put all the elements (data only) into the string.
	String s = "[";
	ListItem listPtr = front;
	while (listPtr != null) {
	    s += " \"" + listPtr.data + "\"";
	    listPtr = listPtr.next;
	}
	return s + "]";
    }


    public void printWithAddresses ()
    {
	if (front == null) {
	    return;
	}

	ListItem listPtr = front;
	while (listPtr != null) {
            //  listPtr's default toString() prints out the memory address.
	    System.out.println (" \"" + listPtr.data + "\"  at address " + listPtr);
	    listPtr = listPtr.next;
	}
    }

}

class ListItem {

    String data;
    ListItem next;    // To point to next node in list.
    ListItem prev;    // To point to the previous node in the list.

}


public class DoublyLinkedList {

    // Instance variables.
    ListItem front = null;
    ListItem rear = null;

    int numItems = 0;

    public void add (String s)
    {
	if (front == null) {
            // Similar to singly-linked list, except for setting rear.prev
	    front = new ListItem ();
	    front.data = s;
	    rear = front;
	    rear.next = null;
	    rear.prev = null;           // Must set this correctly.
	}
	else {
            // Make new ListItem and set its fields correctly.
            ListItem nextOne = new ListItem ();
	    nextOne.data = s;
	    nextOne.next = null;
	    nextOne.prev = rear;

            // Adjust the next pointer of the current last one, and adjust rear itself.
	    rear.next = nextOne;
	    rear = nextOne;
	}    

	numItems ++;
    }


    public int size ()
    {
    	// ...
    }

    
    public String get (int i)
    {
    	// ... same as in singly-linked list ...
    }


    public boolean contains (String s)
    {
    	// ... same as in singly-linked list ...
    }

    public String toString ()
    {
        // ... 
    }
}

class ListItem {

   // ...

}


public class DoublyLinkedList4 {

    // ...

    public void add (String s)
    {
        // ...
    }


    public int size ()
    {
        // ...
    }

    
    public String get (int i)
    {
        // ...
    }


    public boolean contains (String s)
    {
        // ...
    }


    public String toString ()
    {
        // ...
    }



    // Find String s and delete it if it occurs in the list.

    public void delete (String s)
    {
	ListItem listPtr = front;
	while ( (listPtr != null) && (! listPtr.data.equals(s)) ) {
	    listPtr = listPtr.next;
	}

        // If it's not there, return.
	if (listPtr == null) {
	    return;
	}

	// Otherwise delete: four cases.
        if (front == rear) {
            // Case 1: only one element.
            front = rear = null;
        }
	else if (listPtr == front) {
            // Case 2: we're deleting from the front.
	    front = listPtr.next;
            front.prev = null;
	}
	else if (listPtr == rear) {
            // Case 3: delete the last element.
	    rear = listPtr.prev;
            rear.next = null;
	}
	else {
	    // Case 4: In the middle: stitch the prev and next nodes together.
	    listPtr.prev.next = listPtr.next;
	    listPtr.next.prev = listPtr.prev;
	}

	numItems --;
    }



    // Delete the element at a particular position in the list

    public void delete (int i)
    {
        // Check for bad input.
	if ( (i < 0) || (i >= numItems) ) {
	    return;
	}

        // Find the i-th element.
	int count = 0;
	ListItem listPtr = front;
	while ( (listPtr != null) && (count != i) ) {
	    listPtr = listPtr.next;
	    count ++;
	}

	// Otherwise delete: four cases.
        if (front == rear) {
            // Case 1: only one element.
            front = rear = null;
        }
	else if (listPtr == front) {
            // Case 2: we're deleting from the front.
	    front = listPtr.next;
            front.prev = null;
	}
	else if (listPtr == rear) {
            // Case 3: delete the last element.
	    rear = listPtr.prev;
            rear.next = null;
	}
	else {
	    // Case 4: In the middle: stitch the prev and next nodes together.
	    listPtr.prev.next = listPtr.next;
	    listPtr.next.prev = listPtr.prev;
	}

	numItems --;
    }

}