Lists - Essay - Computer Science

We can store a list of ints as an array, but there are disadvantages to this
representation. First, arrays have a fixed length that can’t be changed. If
we want to add items to a list, but the array is full, we have to...

Search in the document preview

Enscript Output

09/15/10
19:00:58 107

CS 61B: Lecture 7
Monday, September 13, 2010

Today’s reading: Goodrich & Tamassia, Section 3.2.

LISTS
=====
We can store a list of ints as an array, but there are disadvantages to this
representation. First, arrays have a fixed length that can’t be changed. If
we want to add items to a list, but the array is full, we have to allocate a
whole new array, and move all the ints from the old array to the new one.

Second, if we want to insert an item at the beginning or middle of an array, we
have to slide a lot of items over one place to make room. This takes time
proportional to the length of the array.

public class List {
int a[];
int lastItem;

public List() {
a = new int[10]; // The number "10" is arbitrary.
lastItem = -1;
}

LINKED LISTS (a recursive data type)
============
We can avoid these problems by choosing a Scheme-like representation of lists.
A linked list is made up of _nodes_. Each node has two components: an item,
and a reference to the next node in the list. These components are analogous
to "car" and "cdr". However, our node is an explicitly defined object.

To simplify programming, let’s add some constructors to the ListNode class.

public ListNode(int i, ListNode n) {
item = i;
next = n;
}

public ListNode(int i) {
this(i, null);
}

These constructor allow us to emulate Scheme’s "cons" operation.

ListNode l1 = new ListNode(7, new ListNode(0, new ListNode(6)));

09/15/10
19:00:58 207

Linked lists vs. array lists
----------------------------
Linked lists have several advantages over array-based lists. Inserting an item
into the middle of a linked list takes just a small constant amount of time, if
you already have a reference to the previous node (and don’t have to walk
through the whole list searching for it). The list can keep growing until
memory runs out.

The following method inserts a new item into the list immediately after "this".

However, linked lists have some disadvantages compared to arrays. Finding the
nth item of a linked list takes time proportional to n, even though it is a
constant-time operation on array-based lists. You have to start at the head
of the list and walk forward n - 1 nodes, one "next" at a time.

Many of the data structures we will study in this class will be attempts to
find a compromise between arrays and linked lists. We’ll be studying data
structures that are fast for both random lookups _and_ random insertions.

Lists of Objects
----------------
For greater generality, let’s change ListNodes so that each node contains not
an int, but a reference to any Java object. In Java, we can accomplish this by
declaring a reference of type Object.

public class SListNode {
public Object item;
public SListNode next;
}

The "S" in "SListNode" stands for singly-linked. This will make sense when we
contrast these lists with doubly-linked lists later. You’ll see the SListNode
class in this week’s lab and homework.

A List Class
------------
There are two problems with SListNodes.

(1) Suppose x and y are pointers to the same shopping list. Suppose we insert
a new item at the beginning of the list thusly:

x = new SListNode("soap", x);

y doesn’t point to the new item; y still points to the second item in x’s
list. If y goes shopping for x, he’ll forget to buy soap.

(2) How do you represent an empty list? The obvious way is "x = null".
However, Java won’t let you call a SListNode method--or any method--on
a null object. If you write "x.nth(1)" when x is null, you’ll get a
run-time error, even though x is declared to be a SListNode.
(There are good reasons for this, which you’ll learn later in the course.)

The solution is a separate SList class, whose job is to maintain the head
(first node) of the list. We will put many of the methods that operate on
lists in the SList class, rather than the SListNode class.