Lists

The basic List interface supports the following features:

L.get(i):  returns the ith element

Vector

Chapter 3 contains Bailey's Vector class, which represents a List of Objects implemented via an array. The main feature is that the vector can grow.

We'll start with the Vector interface on page 46. 

Bailey's examples:

    Vector used for Wordlist

    Vector used for L-systems

There is an issue with Vectors of Objects: we don't really want Objects. Look closely at the code on page 47; it contains a cast to (String):

    targetWord = (String) list.get(index);

What this does is takes the Object list.get(index), and, because it is really a string, allows its use as a string at compile-time.

In C# (and now in fact in Java) we will usually use generics, eg Vector<T>.

In the word-frequency example on page 49 (actually starting on p 48) there is

    wordInfo = (Association) vocab.get(i);

and

    vocabWord = (String) wordInfo.getKey();

Adding to the middle of a vector: you need to move from right to left. See the picture on Bailey p 52.

Vector Growth Demo

§3.5: analysis of costs of expansion

• The number of moves to insert at a random place in the middle of a list of length N is, on average, N/2.
• The number of compares to search a list of length N for a random element that is in fact present is, on average, N/2.
• The number of compares to search a list of length N for an element not there is simply N.

Search and insert costs

Generics

We would really like to be able to declare containers with a fixed type, where the type is supplied as parameter:

    List<String> s = new List<String>();

If we use Bailey's Vector class, we would have pretty much the same performance, but getting strings out of the Vector would always require a cast:

    String s = (String) vect.get(3);

Stack

• s.push(A): adds data value A to the stack
• s.pop(): returns the most recently pushed value, and deletes it from the stack

Implementing a stack

Deleting from a list

If all we do is add, then the growth strategy of doubling the internal space when necessary makes perfect sense.

But what happens if we will regularly grow lists to large size, and then delete most of the entries? A list grown to have internal capacity 1024 will retain that forever, even if we shrink down to just a few elements.

One approach is to re-allocate to a smaller elements[] whenever L.Count < L.Capacity/2, or something like that.

Morin in §2.6 (p 49) introduces what he calls a RootishArrayStack, which is an array-based list with an efficient delete operation. Here are the key facts (big-O notation is officially introduced in the next section):

• The space used for n elements is n + O(√n)
• For any m add/remove operations, the time spent growing and shrinking is O(m)

The idea is to keep a list of arrays (an array of pointers to arrays). These sub-arrays have size 1, 2, 3, 4, etc respectively. For 10 elements, the RootishArrayStack would have four arrays, and thus a capacity of 1+2+3+4.

If the RootishArrayStack has N elements in n arrays, then N ≃ n²/2; this follows because 1+2+...+n ≃ n²/2. When the RootishArrayStack needs to expand, it will add an array of size n+1 to the pool; this is about √(2n). Thus, growth is "slower" than for C# Lists or Java ArrayLists. However, when a new allocation is made for growth, the old space is not discarded.

The real advantage of the RootishArrayStack is for deletions. If the list shrinks so that the last sub-array is now empty, that sub-array and that sub-array only is discarded. This is a relatively efficient operation.

Big-O notation and Bailey Chapter 5: Analysis

A function is said to be polynomial if it is O(n^k) for some fixed k; quadratic growth is a special case.

So far we've been looking mainly at running time. We can also consider space needs. As an example, see the Table of Factors example on Bailey page 88. Let us construct a table of all the k<=n and a list of all the factors (prime or not) of k, and ask how much space is needed. This turns out to be n log n. The argument here is a bit mathematical; see Bailey. If the table length is n, then factor f can appear no more than n/f times (once every fth line).

The running time to construct the table varies with how clever the algorithm is, it can be

• O(n²) [check all i<k for divisibility]
• O(n^3/2) [check all i<sqrt(k)]
• O(n log n) [Sieve of Eratosthenes]

Now suppose we want to search a large string for a specific character. How long should this take? Bailey has an example on p 90. The answer depends on whether we're concerned with the worst case or the average case (we are almost never interested in the best case). If the average case, then the answer typically depends on the probability distribution of the data.

Linked Lists

• Bailey, chapter 9 section 4
• Morin, Chapter 3 (p 63) (we will look at singly-linked lists, or Morin's SLList)

    public class Cell<T> {
       private T data_;
       private Cell<T> next_;
       public Cell(T s, Cell<T> n) {data_ = s; next_ = n;}
       public T data() {return data_;}
       public Cell<T> next() {return next_;}
       public void setData(T s) {data_ = s;}
       public void setNext(Cell<T> c)   {next_ = c;}
    }

Implementing a stack using linkedlist

Implementing a set

Using List<T> to implement a Matrix class in C#

• Matrix(int height, int width)
• getWidth()
• getHeight()
• get(int row, int col)
• set(int row, int col, double val)

How should we proceed?

Here's a simpler problem: how should we implement a Vector<T> class, where vector objects have a fixed length, and are initialized to 0? C# does take care of that latter, but List<T>'s do not automatically have the right length. Also, ideally we'd like to "hide" the add() operation, that can make a List<T> grow longer than we'd like.

Now let's return to the Matrix class. As in Vector, we will pre-allocate space for all the elements. Here is some simple code to implement a matrix class with TList objects; also in matrix.cs (the companion "driver" is in matrixdemo.cs)

/**
 * Class Matrix is implemented by a TList of rows.
 */

class Matrix {
    // instance variables - replace the example below with your own
    private TList<TList<double> > m;
		// list of lists
    private int height, width;

    /**
     * Constructor for objects of class TList
     */
    public Matrix(int h, int w)
    {
        // initialize instance variables
        height = h;
	width = w;
        m = new TList<TList<double>>(height);
	// we must preallocate all the rows
	for (int i = 0; i<height; i++) {
		TList<double> theRow = new TList<double>(width);
		theRow.Fill(0.0);
		// we must preallocate all the slots (columns) in each row
		m.Add(theRow);
	}
    }
       
    public int getwidth() {return width;}
    public int getheight() {return height;}

    // get nth value, with range check
    public double get(int r, int c) {
        if (r<0 || r >= height) {
            Console.WriteLine("Warning: Matrix.get() called with out-of-range row = " + r);
            return 0.0;	
        }
        if (c<0 || c >= width) {
            Console.WriteLine("Warning: Matrix.get() called with out-of-range column = " + c);
            return 0.0;	
        }
        return m.get(r).get(c);
    }
    
    // set nth value, with range check
    public void set(int r, int c, double val) {
        if (r<0 || r >= height) {
            Console.WriteLine("Warning: Matrix.set() called with out-of-range row = " + r);
            return;	
        }
        if (c<0 || c >= width) {
            Console.WriteLine("Warning: Matrix.get() called with out-of-range column = " + c);
            return;	
        }
        m.get(r).set(c,val);
    }    
}

• We're using TList to build a 2-D structure.
• There's no analogue to TList.add(E e); we have to add entire rows or columns or else the Matrix will no longer be neatly rectangular. Note that we add new rows and columns "empty", that is, populated with nulls. (In the code above, there is no way to add a new row or column.)
• Because the generic class uses TLists, not arrays, we don't have any problem using the element type E directly throughout. When we created the Vector and MyList classes, we had that annoying need to use Object when creating arrays even when we wanted EltType.
• Matrix.print(int fieldwidth) is a handy way of generating output. Note the parameter. Because of the parameter, making this into ToString() is tricky. (Not shown above.)
• How do we know all the rows are the same length?

Linked List Efficiency

Stacks and Linked Lists

While the array implementation of a stack is quite fast, the linked list approach is equally straightforward. All we have to do is maintain a pointer to the head:

class stack<T> {
    private Cell<T> head_;
    public bool is_empty() {return (head_ == null);}
    public T pop() {T val = head_.data(); head_ = head_.next(); return val;}
    public void push(T val) {head_ = new Cell<T>(val, head_);}
}

What would we need to do in C++ if we wanted to be sure we deleted a popped cell?

Sorting Linked Lists

How would you sort a linked list? QuickSort is out.

Hashing

• int values
• "d"
• "A"
• " "
• "2"

    "avocado",
    "banana",
    "canteloupe",
    "durian",
    "eggplant",
    "feijoa",

{
    "avocado",
    "banana",
    "canteloupe",
    "durian",
    "eggplant",
    "feijoa",
    "guava",
    "hackberry",
    "iceberg",
    "jicama",
    "kale",
    "lime",
    "mango",
    "nectarine",
    "orange",
    "persimmon",
    "quince",
    "rutabega",
    "spinach",
    "tangerine",
};

Open Hashing

Another way to do hashing is so-called "open" hashing: a data object d is simply put into htable[hash(d)]. If that position is taken, the next position is used. For this to work, we need to be sure that htablesize is quite a bit larger (eg at least double) the number of elements added. Deletions require careful thought. See Bailey 15.4.1.

Traversing a Hash Table

Hash Sets and Hash Dictionaries

One way to implement sets of strings (or of a generic type T) is with lists, as in StrSet.cs:

class StrSet {

    private StrList sl;
    public StrSet() {sl = new StrList(100); }
    public bool isMember(string s) {
        for (int i=0; i<sl.size(); i++) {
            if (sl.get(i) == s) return true;
        }
        return false;
    }

    public void Add(string s) {
	if (isMember(s)) return;
	sl.Add(s);
    }
}
      

class hashset {
    private hashtable ht;
    public hashset(int size) {ht = new hashtable(size);}

    public bool isMember(string s) {
        return ht.isMember(s);
    }

    public void Add(string s) {
	if (isMember(s)) return;
	ht.Add(s);
    }

    public void print() {
	ht.print();
    }
}

Dictionaries

• V get (K key): returns the value corresponding to key, or else default(V) (generally null)
• void add(K key, V val): adds the new pair. Precondition: K is not already present
• void update(K key, V newval): like add. K may or may not be present.

The dictionary example is at dictionary.cs. It contains a simple driver program.

• Use s.Split(" .,;[]()\t") to split at other characters besides spaces
• Convert each word to lowercase

The file dictionary.cs contains a full-fledged implementation of a dictionary type, complete with generics, support for "iterators", and the d[] notation.

	foreach (KeyValuePair<string,int> kvp in d) 
		Console.WriteLine("{0}: {1}", kvp.Key, kvp.Value);

    public class Cell {
	private K key_;
	private V val_;
	private Cell  next_;
	public Cell(K k, V v, Cell n) {key_ = k; val_ = v; next_ = n;}
	public K getKey() {return key_;}
	public V getVal() {return val_;}
	public Cell   next() {return next_;}
        public void setVal(V v) {val_ = v;}
        public void setNext(Cell c)   {next_ = c;}
    }	

	class dictionary : System.Collections.Generic.IEnumerable> {

    IEnumerator> IEnumerable>.GetEnumerator() {
	return foonumerator();
    }

    IEnumerator> foonumerator() {
	for (int i = 0; i(p.getKey(), p.getVal());
		p = p.next();
	    }
	}
	yield break;
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { 
	return foonumerator(); 
    }