Week2 的前部分内容讲的是栈和队列的Java实现。
学习环境：mac, inteliJ, java version "1.8.0_77"

在学习这门课之前，先引入Abstract Data Types(ABT)的概念，即抽象数据类型。ABT将operators封装起来，例如pop,push,这样使用者就不必深入了解技术细节，而是更多关注与解决问题本身。

1 Stacks

1.1 链表实现

/**
 * 学习stack，链表实现
 * Created by susu on 17/1/9.
 */
public class LinkStackTest {
    private Node first = null;
    private class Node
    {
        String item;
        Node next;
    }

    public boolean isEmpty()
    {
        return first == null;
    }

    public void push(String item)
    {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
    }

    public String pop()
    {
        String item = first.item;
        first = first.next;
        return item;
    }
}

1.2 简单的数组实现

2 Resizing Arrays

3 Queues

3.1 链表实现

3.2 简单的数组实现

4 Generics

解决使用栈或者队列时，item 的数据类型指定问题。例如在基础的class中指定了 String item; 那么在其他地方每次使用时，要么复制代码修改类型，要么强制转换。问题是，强制转换是在用户使用端进行转换，报错了的话是无法监测到的，所以可以在链表实现中修改成generics。

note:数组很难实现generics.

/**
 * Generic stack: linked-list implementation
 * Created by susu on 17/1/10.
 */
public class Stack<Item> {
    private Node first = null;

    private class Node
    {
        Item item;
        Node next;
    }

    public boolean isEmpty()
    { return first == null; }

    public void push(Item item)
    {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
    }

    public Item pop()
    {
        Item item = first.item;
        first = first.next;
        return item;
    }
}

5 Iterators

Iteration，迭代器，解决的问题是，使得client 端口在使用stack等数据结构时，能够遍历集合中的元素，而不必要知道我是用数组还是链表实现的。

Iterable，Java的可遍历类，接口,has a method that returns an iterator.
Iterable Interface

public interface Iterable<Item>
{
    Iterator<Item> Iterator();
}

Iterators has methods hasNext(),next()
Iterator Interface

public interface Iterator<Item>
{
    Boolean hasNext();
    Item next();
    void remove();//教授认为这不是一个好method,可能成为调试隐患
}

for-each statement

for (String s : Stack)
    StdOut.println(s);

Stack Iterator: 链表实现

/**
 * Generic stack: linked-list implementation
 * Created by susu on 17/1/10.
 */
import java.util.Iterator;
import java.util.ListIterator;

public class Stack<Item> implements Iterable{
    private Node first = null;

    private class Node
    {
        Item item;
        Node next;
    }

    public boolean isEmpty()
    { return first == null; }

    public void push(Item item)
    {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
    }

    public Item pop()
    {
        Item item = first.item;
        first = first.next;
        return item;
    }
    
    public Iterator<Item> iterator()
    { return new ListIterator()}
    
    private class ListIterator implements Iterator<Item>
    {
        private Node current = first;
        
        public boolean hasNext() { return current != null; }
        public void remove { /* not supported */ }
        public Item next()
        {
            Item item = current.item;
            current = current.next;
            return item;
        }
    }
}

6 Stack and Queue Application

7 作业

作业描述