《算法》笔记 1

• 栈
  • 可变长数组实现
  • 链表实现
  • 数组与链表的对比
• 队列
  • 链表实现

栈

下压栈（简称栈）是一种基于后进后出（LIFO）策略的集合类型。这里学习分别用数组和链表这两种基础数据结构来实现栈。
栈支持的基本操作有push,pop。

可变长数组实现

要用数组实现栈，可以声明一个int型的标记，这个标记指向的位置即为栈顶，push操作时，将值放在数据中标记的位置，同时将标记+1，pop时，返回数组在标记位置的值，同时标记-1。
但java中的数组在声明的时候其长度就已经固定了，所以栈使用的空间只能是这个数组最大容量的一部分。为了能容纳更多的数据而声明一个特别大的数组会非常浪费空间，那如何解决这个问题，达到既不会浪费数组空间也不会超出数组范围呢？
可以采用动态调整数组大小的方式，在push操作导致栈已满时，重新创建一个数组，其容量为原数组的两倍。同理在pop操作使数组的闲置空间达到一定程度时，重新创建一个容量更小的数组。但闲置的判断标准不能为一半1/2，否则会造成在1/2的临界点处push和pop操作时发生“抖动”，即频繁地进行数组扩容、缩容操作，这会极大地降低栈的性能。所以通常的做法是在减少到数组容量的1/4时缩容为1/2。

实现可变长数组的代码如下：

public class StackResizeArray<Item>  {
	private Item[] a; // array of items
	private int n; // number of elements on stack

	public StackResizeArray() {
		a = (Item[]) new Object[2];
		n = 0;
	}

	public boolean isEmpty() {
		return n == 0;
	}

	public int size() {
		return n;
	}

	private void resize(int capacity) {
		assert capacity >= n;

		Item[] temp = (Item[]) new Object[capacity];
		for (int i = 0; i < n; i++) {
			temp[i] = a[i];
		}
		a = temp;
	}

	public void push(Item item) {
		if (n == a.length)
			resize(2 * a.length); // double size of array if necessary
		a[n++] = item; // add item
	}

	public Item pop() {
		if (isEmpty())
			throw new NoSuchElementException("Stack underflow");
		Item item = a[n - 1];
		a[n - 1] = null; // to avoid loitering
		n--;
		// shrink size of array if necessary
		if (n > 0 && n == a.length / 4)
			resize(a.length / 2);
		return item;
	}
}

pop方法中，a[n - 1] = null将数组中已经出栈的位置设为null，是为了避免对象游离，否则这个位置的对象虽然已经不在栈中，但还被数组引用着，导致GC无法对其回收。

链表实现

栈的另外一种实现方式是采用链表，链表是一种递归的数据结构，它或者为空，或者指向一个结点的引用，该结点含有一个泛型的元素和一个指向另一条链表的引用。
构成链表的基本结点可以为：

private static class Node<Item> {
    public Item item;
    public Node next;
}

其中泛型的item变量存放数据，同样是Node类型的next变量用来指向下一个结点。将链表的头部作为栈顶，push相当于在表头插入元素，pop是从表头删除元素。
代码如下：

public class StackLinkedList<Item> {
	private static class Node<Item> {
		public Item item;
		public Node next;
	}

	private Node<Item> first;
	private int N;

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

	public int size() {
		return N;
	}

	public void push(Item item) {
		Node<Item> oldFirst = first;
		first = new Node<Item>();
		first.item = item;
		first.next = oldFirst;
		N++;
	}

	public Item pop() {
		if (isEmpty())
			throw new NoSuchElementException("Stack underflow");
		Item item = first.item;
		first = first.next;
		N--;
		return item;
	}
}

数组与链表的对比

数组与链表的区别决定了两种栈实现的区别：

• 存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取；　
• 存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；　
• 存储空间上，链表由于带有指针域，存储密度不如数组大；　
• 按序号查找时，数组可以随机访问，需要的时间是常数，而链表不支持随机访问，需要的时间与数据规模成线性关系。
• 按值查找时，若数组无序，数组和链表时间复杂度均为O(n)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；
• 插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可；　
• 空间分配方面： 虽然可变长数组可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败； 链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效；

队列

链表实现

先进先出队列（简称队列）是一种基于先进先出(FIFO)策略的集合类型。这里只关注队列的链表实现。与链表实现的栈类似，用结点包含泛型的item变量和next变量，前者存放数据，后者用来指向下一个结点。不同之处在于链表的头部、尾部都会被操作，从链表的一端入队(enqueue)，从另一端出队(dequeue)
代码：

public class Queue<Item> {
    private static class Node<Item> {
        public Item item;
        public Node next;
    }

    private Node<Item> first;
    private Node<Item> last;
    private int N;

    public void enqueue(Item item) {
        Node<Item> oldLast = last;
        last = new Node<Item>();
        last.item = item;
        if (isEmpty()) {
            first = last;
        } else {
            oldLast.next = last;
        }
        N++;
    }

    public Item dequeue() {
        if (isEmpty()) {
            return null;
        }
        Item result = first.item;
        first = first.next;
        if (isEmpty()) {
            last = null;
        }
        N--;
        return result;
    }

    public boolean isEmpty() {
        return N == 0;
    }

    public int size() {
        return N;
    }
}