Algorithms (Java) Bags,Queues,and Stacks（1）

前言

---

 

许多基础数据类型都和对象的集合有关。具体来说，数据类型的值就是一组对象的集合，所有操作都是关于添加，删除或是访问集合中的对象。接下来，介绍三种数据类型，背包，队列，栈。语言是表达的载体，所以不可避免在表达算法时，依赖于语言的一些特性。

---

 

 

 

 正文

---

介绍两种表示对象集合的方式，即数组和链表。两种都非常基础，常常被称为顺序存储和链式存储。下面我们先介绍数组形式。

 

背包：是一种不支持删除元素的集合数据类型，它的目的就是帮助用例收集元素并迭代遍历所有收集到的元素。就像一个袋子里

装弹珠，不过是一次一个。从背包口添加元素，也是从背包口出来，是后进先出。

 

先进先出队列（简称队列）：就像平常所见到的排队，从队尾添加元素，从队的前面删除

元素，就像自来水管通水。先进先出。

 

下压栈（简称栈）：是一种基于后进先出策略的集合类型。就像试管，只能从管口倒水，从管口出水。这说明添加元素是从管口，删除元素也是从管口。

 

---

 

我们先来看一种容量固定的字符串栈的抽象数据类型。它只能处理String值，要求用例指定一个容量且不支持迭代（迭代后面会讲述)。实现一份API的第一步就是选择数据的表达方式，对于这个，我们显然可以选择String数组。

public class FixedCapacityStackOfStrings {
private String[] a; // holds the items
private int N; // number of items in stack
// create an empty stack with given capacity
public FixedCapacityStackOfStrings(int capacity) {
a = new String[capacity];
N = 0;
}
public boolean isEmpty() {
return N == 0;
}
public boolean isFull() {
return N == a.length;
}
public void push(String item) {
a[N++] = item;
}
public String pop() {
return a[--N];
}
public String peek() {
return a[N - 1];
}
｝

测试用例为：

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int max = in.nextInt();
FixedCapacityStackOfStrings stack = new FixedCapacityStackOfStrings(max);
while (!StdIn.isEmpty()) {
String item = StdIn.readString();
if (!item.equals("-"))
stack.push(item);
else if (stack.isEmpty())
StdOut.println("BAD INPUT");
else
StdOut.print(stack.pop() + " ");
}
StdOut.println();
// print what's left on the stack
StdOut.print("Left on stack: ");
for (String s : stack) {
StdOut.print(s + " ");
}
StdOut.println();
}

 这种实现的主要性能特点是push和pop操作所需的时间独立于栈的长度。通俗来说就是和栈的长度无关，与数据的多少无关，这在操作许多数据时能极大节省时间。

 

下面给出这段代码的完整版（注意将StdOut.javahttp://introcs.cs.princeton.edu/java/15inout/StdOut.java和StdIn.javahttp://introcs.cs.princeton.edu/java/stdlib/StdIn.java添加加你文件所在的包下）：

/******************************************************************************
* Compilation: javac FixedCapacityStackOfStrings.java
* Execution: java FixedCapacityStackOfStrings
* Dependencies: StdIn.java StdOut.java
*
* Stack of strings implementation with a fixed-size array.
*
* % more tobe.txt
* to be or not to - be - - that - - - is
*
* % java FixedCapacityStackOfStrings 5 < tobe.txt
* to be not that or be
*
* Remark: bare-bones implementation. Does not do repeated
* doubling or null out empty array entries to avoid loitering.
*
******************************************************************************/
 
import java.util.Iterator;
import java.util.NoSuchElementException;
 
public class FixedCapacityStackOfStrings implements Iterable<String> {
private String[] a; // holds the items
private int N; // number of items in stack
 
// create an empty stack with given capacity
public FixedCapacityStackOfStrings(int capacity) {
a = new String[capacity];
N = 0;
}
 
public boolean isEmpty() { return N == 0; }
public boolean isFull() { return N == a.length; }
public void push(String item) { a[N++] = item; }
public String pop() { return a[--N]; }
public String peek() { return a[N-1]; }
public Iterator<String> iterator() { return new ReverseArrayIterator(); }
 
 
public class ReverseArrayIterator implements Iterator<String> {
private int i = N-1;
 
public boolean hasNext() {
return i >= 0;
}
 
public String next() {
if (!hasNext()) throw new NoSuchElementException();
return a[i--];
}
 
public void remove() {
throw new UnsupportedOperationException();
}
}
 
 
public static void main(String[] args) {
int max = Integer.parseInt(args[0]);
FixedCapacityStackOfStrings stack = new FixedCapacityStackOfStrings(max);
while (!StdIn.isEmpty()) {
String item = StdIn.readString();
if (!item.equals("-")) stack.push(item);
else if (stack.isEmpty()) StdOut.println("BAD INPUT");
else StdOut.print(stack.pop() + " ");
}
StdOut.println();
 
// print what's left on the stack
StdOut.print("Left on stack: ");
for (String s : stack) {
StdOut.print(s + " ");
}
StdOut.println();
}
}

(tobe.txt文件内容为：to be or not to - be - - that - - - is)

---

 

 

分析

---

缺点：只能处理String数组。

如果我们想处理double型，或者其他类型，则得将所有String换成double，这是极其不方便的。但是Java有一种机制可以解决这个问题，就是泛型。就是将所有的String都替换成Item（但在测试用例中不用改，正是这里的类型会将Item替换成你所填入的类型），Item是一个类型参数，用于表示象征性的占位符。可以将

public class FixedCapacityStack<Item>

理解为某种元素的栈。就是它可以代替任何类型，只是你现在不知道，当你实现这个数据类型时，可以先不管他是这个栈所要收集的类型是什么，通用性特别强，能处理任意数据类型，等到在测试用例中再去定义这个类型，即把Item替换成你想要的类型。比如

FixedCapacityStack<String> stack = new FixedCapacityStack<String>(max)

这个时候就定义为String型的了，代表这个栈是收集字符串类型的数据。就是说在创建栈时提供具体的数据类型，他就能用栈处理任意数据类型。实际的类型必须是引用类型，但用例可以依靠自动装箱将原始数据类型转换为相应的封装类型。Java会使用类型参数Item来检查类型不匹配的错误——尽管具体类型还不知道，赋予Item类型变量的值也必须是Item类型的。由于某些原因，创建泛型数组在Java数组是不允许的，我们需要使用类型转换，

a = (Item[]) new Object[cap];

虽然有警告，但可以忽略。

下面给出带有泛型的代码：

/******************************************************************************
* Compilation: javac FixedCapacityStack.java
* Execution: java FixedCapacityStack
* Dependencies: StdIn.java StdOut.java
*
* Generic stack implementation with a fixed-size array.
*
* % more tobe.txt
* to be or not to - be - - that - - - is
*
* % java FixedCapacityStack 5 < tobe.txt
* to be not that or be
*
* Remark: bare-bones implementation. Does not do repeated
* doubling or null out empty array entries to avoid loitering.
*
******************************************************************************/
 
import java.util.Iterator;
import java.util.NoSuchElementException;
 
public class FixedCapacityStack<Item> implements Iterable<Item> {
private Item[] a; // holds the items
private int N; // number of items in stack
 
// create an empty stack with given capacity
public FixedCapacityStack(int capacity) {
a = (Item[]) new Object[capacity]; // no generic array creation
N = 0;
}
 
public boolean isEmpty() { return N == 0; }
public void push(Item item) { a[N++] = item; }
public Item pop() { return a[--N]; }
public Iterator<Item> iterator() { return new ReverseArrayIterator(); }
 
 
public class ReverseArrayIterator implements Iterator<Item> {
private int i = N-1;
 
public boolean hasNext() {
return i >= 0;
}
 
public Item next() {
if (!hasNext()) throw new NoSuchElementException();
return a[i--];
}
 
public void remove() {
throw new UnsupportedOperationException();
}
}
 
 
public static void main(String[] args) {
int max = Integer.parseInt(args[0]);
FixedCapacityStack<String> stack = new FixedCapacityStack<String>(max);
while (!StdIn.isEmpty()) {
String item = StdIn.readString();
if (!item.equals("-")) stack.push(item);
else if (stack.isEmpty()) StdOut.println("BAD INPUT");
else StdOut.print(stack.pop() + " ");
}
StdOut.println();
 
// print what's left on the stack
StdOut.print("Left on stack: ");
for (String s : stack) {
StdOut.print(s + " ");
}
StdOut.println();
}
}

 可和前面的没有泛型的代码对比理解。

---

 

 

下面讲述另一个缺点：一开始必须预先估计栈的最大容量。选择大的容量会浪费内存，栈的使用空间只能是这个最大容量的一部分。但又不能导致溢出，因此我们必须去判断栈是否已满。因此我们希望解决这个问题，创建一个数组，既要足以保存所有的元素，又不至于浪费过多的空间。

第一步：将栈移动到另一个大小不同的数组，然后比较栈大小N和数组大小a.length是否相等来检查数组是否能容纳新的元素，如果没有多余的空间，我们会将数组的长度加倍。当删除元素时，检测栈大小是否小于数组的四分之一，如果小于，则将数组长度减小为二分之一。这样，栈永远不会溢出，使用率永远不会低于四分之一（除非栈为空）。

/******************************************************************************
* Compilation: javac ResizingArrayStack.java
* Execution: java ResizingArrayStack < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: http://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* Stack implementation with a resizing array.
*
* % more tobe.txt
* to be or not to - be - - that - - - is
*
* % java ResizingArrayStack < tobe.txt
* to be not that or be (2 left on stack)
*
******************************************************************************/
 
import java.util.Iterator;
import java.util.NoSuchElementException;
 
/**
* The <tt>ResizingArrayStack</tt> class represents a last-in-first-out (LIFO) stack
* of generic items.
* It supports the usual <em>push</em> and <em>pop</em> operations, along with methods
* for peeking at the top item, testing if the stack is empty, and iterating through
* the items in LIFO order.
* <p>
* This implementation uses a resizing array, which double the underlying array
* when it is full and halves the underlying array when it is one-quarter full.
* The <em>push</em> and <em>pop</em> operations take constant amortized time.
* The <em>size</em>, <em>peek</em>, and <em>is-empty</em> operations takes
* constant time in the worst case.
* <p>
* For additional documentation,
* see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
* <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
*
* @author Robert Sedgewick
* @author Kevin Wayne
*/
public class ResizingArrayStack<Item> implements Iterable<Item> {
private Item[] a; // array of items
private int N; // number of elements on stack
 
 
/**
* Initializes an empty stack.
*/
public ResizingArrayStack() {
a = (Item[]) new Object[2];
N = 0;
}
 
/**
* Is this stack empty?
* @return true if this stack is empty; false otherwise
*/
public boolean isEmpty() {
return N == 0;
}
 
/**
* Returns the number of items in the stack.
* @return the number of items in the stack
*/
public int size() {
return N;
}
 
 
// resize the underlying array holding the elements
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;
}
 
/**
* Adds the item to this stack.
* @param item the item to add
*/
public void push(Item item) {
if (N == a.length) resize(2*a.length); // double size of array if necessary
a[N++] = item; // add item
}
 
/**
* Removes and returns the item most recently added to this stack.
* @return the item most recently added
* @throws java.util.NoSuchElementException if this stack is empty
*/
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;
}
 
 
/**
* Returns (but does not remove) the item most recently added to this stack.
* @return the item most recently added to this stack
* @throws java.util.NoSuchElementException if this stack is empty
*/
public Item peek() {
if (isEmpty()) throw new NoSuchElementException("Stack underflow");
return a[N-1];
}
 
/**
* Returns an iterator to this stack that iterates through the items in LIFO order.
* @return an iterator to this stack that iterates through the items in LIFO order.
*/
public Iterator<Item> iterator() {
return new ReverseArrayIterator();
}
 
// an iterator, doesn't implement remove() since it's optional
private class ReverseArrayIterator implements Iterator<Item> {
private int i;
 
public ReverseArrayIterator() {
i = N-1;
}
 
public boolean hasNext() {
return i >= 0;
}
 
public void remove() {
throw new UnsupportedOperationException();
}
 
public Item next() {
if (!hasNext()) throw new NoSuchElementException();
return a[i--];
}
}
 
 
/**
* Unit tests the <tt>Stack</tt> data type.
*/
public static void main(String[] args) {
ResizingArrayStack<String> s = new ResizingArrayStack<String>();
while (!StdIn.isEmpty()) {
String item = StdIn.readString();
if (!item.equals("-")) s.push(item);
else if (!s.isEmpty()) StdOut.print(s.pop() + " ");
}
StdOut.println("(" + s.size() + " left on stack)");
}
}

 

注意这里：

 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;
}

 

这里

 a[N-1] = null; // to avoid loitering 

避免对象游离，Java的垃圾回收策略是回收所有无法被访问的对象的内存。pop（）的实现中，被弹出的元素的引用仍然存在于数组中。这个元素永远不会被访问了，但Java收集器没法知道这一点，除非该引用被覆盖。即使用例已经不再需要这个元素，数组中的引用仍然可以让它继续存在。这种情况称为游离。避免对象游离，只需将被弹出的数组元素的值设为null，这将覆盖无用的引用并使系统可以在用例使用完被弹出的元素后回收它的内存。

2015-11-07 18:56:30