CS62 - Fall 2020

CS62 - Fall 2020 - Class 9

Example code in this lecture

Lecture notes

admin
   - midterm next week in lab
   - review next Tuesday
   - Darwin
   - Another assignment tomorrow (start early!)

command-line arguments
   - Eclipse is an IDE (interactive development environment)
      - it does a lot of things for you including syntax highlighting, autogeneration of some code, debugging, etc.
      - one of the other things it does for you is compile your code and then run it

   - Java is a compiled language
      - we first compile the code
         - this checks the syntax of your code
         - and generates a runnable version of your code (.class file in the class of Java)
      - we can then run the code once it is compiled

   - We can compile Java from the command line (e.g., Terminal)
      - cd into the directory where either the .java file exists (if no package) or the top level package exists
      - if no package:
         - javac MyFile.java

      - if package
         - javac package_name.MyFile.java

      - you can do multiple java files with *

   - Once compiled, you can run them:
      - java MyFile
      - java package_name.MyFile

   - when running a java program on the command-line, you can also pass arguments to the program (think, inputs) by adding extra information on the command-line
      - java MyFile more information

      - any text after the name of the file get passed as arguments to your main method!
         - the things are separated by a space so
            java MyFile more information

            - would pass two pieces of information

Look at the CommandLine class in CommandLine code
   - only a main method
      - iterates through the String[] and prints it out

   - if we run the code in Eclipse is just prints out 0

   - we can call it from the command-line, though
      $ javac CommandLine.java

      $ java CommandLine
      Length: 0

      $ java CommandLine this is some stuff
      Length: 4
      0:   this
      1:   is
      2:   some
      3:   stuff

   - You can do this in Eclipse too
      - Next to the run button, you can open the run dropdown menu
      - select "Run Configurations..."
      - under the "Arguments" tab there is a "Program arguments" field where you can enter command-line arguments

Quick refresher on linked lists

Write a method addLast for the LinkedList class

See slides!

look at the addLast method in the LinkedList class from LinkedList code
   - if it's empty, set the head equal to the new node
   - otherwise, traverse until we find the last node
      - the last node with have .next() == null
   - add a new node to the last node

how would we remove an element?
   - look at the remove method in the LinkedList class from LinkedList code
   - if its the head, just move the head along
   - if its not the head, need to find the element right before it
   - eventually, splice it out!

Which of these methods are fast/slow for singly linked lists?
   - add to the end (slow)
   - add to the front (fast)
   - contains (slow)
   - get (slow)
   - insert at an index
   - remove an element
   - set the value of an existing element
   - size

What does the singly linked list buy us?
   - add and remove at the front of the list in constant time!
   - what is the downside (no free lunch!)?
      - get and set are now linear time operations
      - size is linear time. Could we do better?
         - just keep another instance variable that is the number of elements

Making it even better
   - Can you see any easy way to speed up any of these?
   - add just appends one thing on to the end of the list, it seems unfortunate that this takes linear time. How could we make it faster?
      - keep a tail reference
      - how does this help us?
         public addLast(E value){
            if( head == null ){
               head = new Node<E>(value);
               tail = head;
            }else{
               tail.setNext(new Node<E>(value);
               tail = tail.next();
            }
         }

      - what's the running time? Now it's constant!
   - what are the downsides to using a tail pointer?
      - more memory (though only marginally)
      - makes a few of the methods slightly more complicated
   - Can we get rid of it?
      - what would happen if we connected the next reference of the last element to the head of the list?

Circularly linked lists
   - In a circularly linked list, all nodes have a next reference creating one big loop
   - Do we still need both a head and a tail reference?
      - the head reference is just tail.next()
         - note that even when there is only one element, we'll still have a loop (with just one element) and therefore tail.next() will still reference the head of the list
   - Did we lose any functionality from before?
      - no, we can still add things and remove things to the head of the list in constant time
      - and add things to the tail of the list in constant time

Doubly linked list
   - We can remove items quickly from the front of the list. What if we want to remove items from the end of the list?
      - ideally, you'd like to just splice it off
      - the problem, though, is that you need to know what the previous node is to do this, so you'd have to search through the list, which would still take linear time
   - the linked list we've seen so far is called a singly linked list since we just have a single forward link
   - in a doubly linked list our Node class has both a next reference as well as a prev reference
   - How does this help us?
      - for simplicity, we'll say it's not a circularly linked list
      - given the tail, we can "splice" out that node:
         tail = tail.prev();
         tail.setNext(null);
      - there are a few more details to deal with the case when we have < 2 nodes, but it's still a constant time operation now!
   - What if someone gives you a Node, call it d, and says that they want you delete it from the doubly linked list?
      d.prev().setNext() = d.next();
      d.next().setPrev() = d.prev();

      - we just splice it out
      - again, there are a few more details to deal with with respect to the head, etc., but it's now a constant time operation!
      - When could this happen?
         - delete all occurrences of a particular value
         - any time we have to iterate over the data already

List fast vs. slow

      ArrayList   Singly LL   Singly LL (tail)   Doubly   LL

add to end   fast      slow      fast         fast
add to front   slow      fast      fast         fast
contains   slow      slow      slow         slow
get      fast      slow      slow         slow
insert at index   slow      slow      slow         slow
remove      slow      slow      slow         slow (fast if given node)
remove at end   fast      slow      slow         fast
set      fast      slow      slow         slow
size      fast      fast      fast         fast

Java also has a LinkedList class that implements the List interface
- http://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html