1. John Hurley Cal State LA
CS203 Lecture 4
John Hurley
Cal State LA

2. More Data Structures Memorize This!
A data structure is a systematic way to organize information in order to improve the efficiency of algorithms that will use the data

3. More Data Structures
So far we have studied arrays and lists, specifically ArrayLists, in detail, and also discussed stacks. As you know, this class is called "Programming With Data Structures," and obviously, data structures are the main topic of the course. Over the next few weeks, we will introduce a wide array (ha!) of new data structures. Most of these data structures can be used as collections of wide ranges of parameterized types We will first learn to use some of the data structure types included with the JDK, then implement one or two on our own, then return to using the built-in ones.

4. Java Collection Framework
A collection is a container object that holds a group of objects, often referred to as elements.
The Java Collections Framework supports three types of collections, named sets, lists, and maps.

5. Java Collection Framework hierarchy, cont.
Set and List are subinterfaces of Collection.

6. The Collection Interface
The Collection interface is the root interface for manipulating a collection of objects.

7. ArrayList and LinkedList
Like an array, a list stores elements in a sequential order, and allows the user to specify where the element is stored. The user can access the elements by index.
Recall that an array is fixed once it is created. An array is suitable if your application does not require insertion or deletion of elements.
A list can grow or shrink dynamically. ArrayList and LinkedList are the most common concrete implementations of the List interface.
If you need to support random access through an index without inserting or removing elements from any place other than the end, ArrayList offers the most efficient collection. ArrayList is implemented using an underlying array that begins with a default size. If the list outgrows the array, a new array must be created and the contents of the old one copied. Inserting values at arbitrary spots in the list involves moving all the subsequent elements.
If your application requires the insertion or deletion of elements from arbitrary locations in the list, use a LinkedList.

8. The List Interface, cont.

9. java.util.ArrayList

10. Linked Lists
A linked list is a data structure consisting of a group of nodes which represent a
sequence.
In the simplest form of linked list, each node is composed of a datum and a reference
(in other words, a link) to the next node in the sequence. This is called a singly
linked list.
We will learn more about how linked lists are implemented in a few weeks;
this week we will use the Java Collections Framework LinkedList<E> class.

11. Linked Lists
In a doubly linked list, each node contains a reference to the next node and
a reference to the previous node.
Either a singly or double linked list may be circular; that is, last node
points to the first, and, in a circular doubly-linked list, the first node has a reference
to the last
Diagrams from Wikipedia:

12. Linked Lists
Adding and removing elements from any spot in a linked list involves changing,
at most, one reference in each of two existing elements and setting, at most, two
references in a new element. Compare this to the expense of periodically creating
a new array and copying all the elements from an old one.
Add a node to a singly-linked list:
Inserting a node into a doubly linked list just involves also changing the reference
from the subsequent element and adding one from the new element back to the
previous one

13. Linked Lists
Delete a node from a singly-linked list:

14. java.util.LinkedList
LinkedList implements a doubly-linked list. It is a subclass of a hierarchy of
List classes, but more importantly it implements the List interface.

15. package demos;
import java.util.*;
public class TestArrayAndLinkedList {
public static void main(String[] args) {
List<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(1); // 1 is autoboxed to new Integer(1)
arrayList.add(2);
arrayList.add(3);
arrayList.add(1);
arrayList.add(4);
arrayList.add(0, 10);
arrayList.add(3, 30);
System.out.println("A list of integers in the array list:");
System.out.println(arrayList);
LinkedList<Object> linkedList = new LinkedList<Object>(arrayList);
linkedList.add(1, "red");
linkedList.removeLast();
linkedList.addFirst("green");
System.out.println("Display the linked list backward:");
for (int i = linkedList.size() - 1; i >= 0; i--) {
System.out.print(linkedList.get(i) + " "); }

16. Linked Lists
Based on the info above, you might expect linked lists to be much more
efficient than array lists. However, data in a linked list is accessed sequentially;
we start at the head of the list and follow the references. This is called
traversing the list.
node = list.firstNode
while node not null
(do something with node.data)
node = node.next
Source for pseudocode: Wikipedia
This may make a linked list less efficient than an array list for operations that
require a great deal of traversal, because accessing an array element by index
Is efficiently implemented.
Also, memory is allocated on the fly when a node is added. This makes it more
likely that different nodes will be far apart in memory, which makes it more
expensive to traverse the list.

17. package listcompare;
public class StopWatch {
private long elapsedTime;
private long startTime;
private boolean isRunning;
public StopWatch() {
reset(); }
public void start() {
if (isRunning) {
return;
isRunning = true;
startTime = System.currentTimeMillis();
public void stop() {
if (!isRunning) {
isRunning = false;
long endTime = System.currentTimeMillis();
elapsedTime = elapsedTime + endTime - startTime;

18. public long getElapsedTime() {
if (isRunning) {
long endTime = System.currentTimeMillis();
return elapsedTime + endTime - startTime;
} else {
return elapsedTime; }
public void reset() {
elapsedTime = 0;
isRunning = false;

19. package listcompare;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
public class ListComparer {
Random r = new Random();
public void arrayListSequentialAdds() {
List<Integer> al = new ArrayList<Integer>();
for (int counter = 0; counter < ; counter++) {
al.add(0, counter);
//System.out.println(counter); }
public void linkedListSequentialAdds() {
List<Integer> ll = new LinkedList<Integer>();
ll.add(0, counter);
public void arrayListRandomAdds() {
al.add(r.nextInt(al.size() + 1), counter);
public void linkedListRandomAdds() {
ll.add(r.nextInt(ll.size() + 1), counter);

20. package listcompare;
public class ListDriver {
public static void main(String[] args) {
StopWatch s = new StopWatch();
ListComparer l = new ListComparer();
s.reset();
s.start();
l.arrayListSequentialAdds();
s.stop();
System.out.println("Array List sequential exercise took " + s.getElapsedTime() + " ms");
l.linkedListSequentialAdds();
System.out.println("Linked List sequential exercise took " + s.getElapsedTime() + " ms");
l.arrayListRandomAdds();
System.out.println("Array List random exercise took " + s.getElapsedTime() + " ms");
l.linkedListRandomAdds();
System.out.println("Linked List random exercise took " + s.getElapsedTime() + " ms"); }

21. I/O Expense
This is a good time to point out that I/O is very expensive. Rerun the code above with the System.out.println statements uncommented.