s_linked_list.py & SLinkedList.java

class SSLNode:
 
 
 
     
    def __init__(self, item, nextnode):
        self.element = item
        self.next = nextnode 
 
 
 
 
class SLinkedList:
 
 
 
     
    def __init__(self):
        self.first = None
        self.size = 0
 
 
    def __str__(self):
        outstr = "-"
        node = self.first
        while node:
            outstr = outstr + 
                str(node.element) + "-"
            node = node.next
        return outstr
           
           
           
    def add_last(self, element):
        newnode = SSLNode(element, None)
        if self.first == None:
            self.first = newnode
        else:
            node = self.first
            while node.next:
                node = node.next
            node.next = newnode
        self.size = self.size + 1
 
 
 
 
 

class SSLNode {
    
   Object element;
   SSLNode next;
        
   public SSLNode(Object item, SSLNode nextnode) {
       element = item;
       next = nextnode; 
   }
    
}
   
class SLinkedList {
    
   private SSLNode first;
   private int size;
    
   public SLinkedList() {
      first = null;
      size = 0;
   }

   public String toString() {
      String outstr = "-";
      SSLNode node = first;
      while (node != null) {
         outstr = outstr + 
             node.element.toString() + "-";
         node = node.next;
      }
      return outstr;
   }
           
   public void addLast(Object element) {
      SSLNode newnode = new SSLNode(element, null);
      if (first == null) {
         first = newnode;
      } else {
         SSLNode node = first;
         while (node.next != null) {
            node = node.next;
         }
         node.next = newnode;
      }
      size = size + 1;
   }

}

list_tester.py and ListTester.java

from s_linked_list import SSLNode
from s_linked_list import SLinkedList

def test_linkedlist():
    mylist = SLinkedList()
    mylist.add_last('a')
    mylist.add_last('b')
    mylist.add_last('c')
    print(mylist)
    
test_linkedlist()
 

class ListTester {
 
 
   public static void main(String[] args) {
      SLinkedList mylist = new SLinkedList();
      mylist.addLast("a");
      mylist.addLast("b");
      mylist.addLast("c");
      System.out.println(mylist);
   }

}

Data structures in the standard library

• We often don't need to 'roll our own' data structures because the Java standard library contains many class definitions for data structures already, e.g.
  • java.util.ArrayList
  • java.util.LinkedList
  • java.util.Stack
  • java.util.ArrayDeque
  • java.util.PriorityQueue
  • java.util.HashSet
  • java.util.TreeSet
  • java.util.HashMap
  • java.util.LinkedHashMap
  • java.util.TreeMap
  and more
• They have loads of useful methods
• But these are generic data structures

Generic data structures

• These data structures can contain any Objects
• But, when you create them, you can also specify what class you want to store in them

  LinkedList<LibraryBook> library = new LinkedList<LibraryBook>();

  (You'll need to import java.util.LinkedList)
• Now, you can only store LibraryBooks (or subclasses of LibraryBook, if any)
  • If you try to store something else, you get a compile-time error:

    library.addLast(new Cow()); // error

• The advantage is: there is a reduced need for casting:

  LibraryBook b = library.getFirst();

Advanced: your own generic data structures

class SSLNode<T> {
    
    T element;
    SSLNode next;
        
    public SSLNode(T item, SSLNode nextnode) {
        element = item;
        next = nextnode; 
    }
    
}
    
class SLinkedList<T> {
    
    private SSLNode first;
    private int size;
    
    public SLinkedList() {
        first = null;
        size = 0;
    }

    public String toString() {
        String outstr = "-";
        SSLNode node = first;
        while (node != null) {
            outstr = outstr + node.element.toString() + "-";
            node = node.next;
        }
        return outstr;
    }

    public void addLast(T element) {
        SSLNode newnode = new SSLNode<T>(element, null);
        if (first == null) {
            first = newnode;
        } else {
            SSLNode node = first;
            while (node.next != null) {
                node = node.next;
            }
            node.next = newnode;
        }
        size = size + 1;
    }

}

Java interfaces

• There is a part of the Java language called an 'interface'
• To distinguish, we will call it a Java interface
• A Java interface is just a collection of abstract methods (i.e. we give the signatures but not the bodies)
• E.g.

  interface Stack {
                      
      public void push(Object element);
      
      public Object pop();
      
      public Object top();
      
      public int length();
      
      public boolean isEmpty();
      
  }

Class definitions vs. Java interfaces

• Contrast:
  • a class definition can contain constructors, variables and methods (comprising each method's signature and body, unless abstract)
  • a Java interface can contain only public method signatures and (advanced point) named constants
• A Java interface acts like a specification
  • it specifies, e.g., what it means to be a stack
  • i.e. to be a stack, an object must offer (at least) these methods
  • Q: What would such a specification be called in CS2515/CS2516?

Implementing a Java interface

• When you write a class definition, you can declare that it 'implements a Java interface', i.e. it meets the specification:

  class ArrayBasedStack implements Stack {
  
      private Object[] s;
      private int capacity;
      private int size;
      
      public ArrayBasedStack(int capacity) {
          this.capacity = capacity;
          s = new Object[capacity];
      }
                      
      public void push(Object element) {
          if (size == capacity) {
              return;
          }
          s[size] = element;
          size = size + 1;
      }
      
      public Object pop() {
          if (size == 0) {
              return null;
          }
          size = size - 1;
          return s[size];
      }
      
      public Object top() {
          if (size == 0) {
              return null;
          }
          return s[size - 1];
      }
      
      public int length() {
          return size;
      }
      
      public boolean isEmpty() {
          return size == 0;
      }
      
  }

Implementing a Java interface

• And here's another class definition that implements the same Java interface:

  import java.util.LinkedList;
  
  class LinkedListBasedStack implements Stack {
  
      private LinkedList s;
      
      public LinkedListBasedStack() {
          s = new LinkedList();
      }
                      
      public void push(Object element) {
          s.addFirst(element);
      }
      
      public Object pop() {
          return s.remove();
      }
      
      public Object top() {
          if (s.size() == 0) {
              return null;
          }
          return s.getFirst();
      }
      
      public int length() {
          return s.size();
      }
      
      public boolean isEmpty() {
          return s.isEmpty();
      }
      
  }

More polymorphism and dynamic method binding

• Polymorphism:
  • A variable of a superclass type may reference objects of that class or its subclasses
  • A variable of a Java interface type may reference objects from any class that implements the Java interface

    Stack s1;
    Stack s2;
    s1 = new ArrayBasedStack(10);
    s2 = new LinkedListBasedStack();

• Dynamic method binding is deciding at run-time which of several methods to run, based on the object being referenced:

  s1.push(new Cow());
  s2.push("Hi")

Java interfaces: what's the point?

• Using Java interfaces polymorphically gives you code that is more easily modified
• Consider how much error-prone effort is involved in changing a large project from using a LinkedListBasedStack to an ArrayBasedStack in code that doesn't use Java interfaces:

  public void method1() {
      LinkedListBasedStack s = new LinkedListBasedStack();
      s.push(new Cow());
      method2.(s);
      method3(s);
  }
  
  public void method2(LinkedListBasedStack st) {
      System.out.println(st.top());
  }
  
  public void method2(LinkedListBasedStack st) {
      st.push(new Pig());
  }

Java interfaces: what's the point? cont'd

• See how easy it is to change from using a LinkedListBasedStack to using an ArrayBasedStack in code that does use Java interfaces:

  public void method1() {
      Stack s = new LinkedListBasedStack();
      s.push(new Cow());
      method2.(s);
      method3(s);
  }
  
  public void method2(Stack st) {
      System.out.println(st.top());
  }
  
  public void method2(Stack st) {
      st.push(new Pig());
  }