栈的介绍
栈（stack），是一种线性存储结构，它有以下几个特点：
- 栈中数据是按照"后进先出（LIFO, Last In First Out）"方式进出栈的。
- 向栈中添加/删除数据时，只能从栈顶进行操作。
栈通常包括的三种操作：push、peek、pop。
- push -- 向栈中添加元素。
- peek -- 返回栈顶元素。
- pop -- 返回并删除栈顶元素的操作。
下方这个示例图就是一个典型的栈型结构。在栈中有一个指针Top，永远指向栈顶元素，如果栈为空，那么Top就为nil。在栈结构中无论是入栈还是出栈，都是操作栈顶元素。所以入栈顺序与出栈顺序是相反的。
栈型结构示例图
栈的示意图
栈的示意图
栈中的数据依次是 30 --> 20 --> 10
出栈
出栈示意图
出栈前：栈顶元素是30。此时，栈中的元素依次是 30 --> 20 --> 10
出栈后：30出栈之后，栈顶元素变成20。此时，栈中的元素依次是 20 --> 10
入栈
入栈示意图
入栈前：栈顶元素是20。此时，栈中的元素依次是 20 --> 10
入栈后：40入栈之后，栈顶元素变成40。此时，栈中的元素依次是 40 --> 20 --> 10
Stack的实现
栈是一种后进先出的数据结构，对于Stack 我们希望至少要对外提供以下几个方法：
| 名称 | 描述 |
|---|---|
| Stack<T>() | 创建一个空的栈 |
| void Push(T s) | 往栈中添加一个新的元素 |
| T Pop() | 移除并返回最近添加的元素 |
| boolean IsEmpty() | 栈是否为空 |
| int Size() | 栈中元素的个数 |
栈的Java实现
JDK包中也提供了"栈"的实现，它就是集合框架中的Stack类。
数组实现的栈，能存储任意类型的数据。
package com.pingkeke.rdf.sample;
import java.lang.reflect.Array;
/**
* 数组实现的栈，能存储任意类型的数据.
*/
public class GeneralArrayStack<T> {
private static final int DEFAULT_SIZE = 12;
private T[] mArray;
private int count;
public GeneralArrayStack(Class<T> type) {
this(type, DEFAULT_SIZE);
}
public GeneralArrayStack(Class<T> type, int size) {
// 不能直接使用mArray = new T[DEFAULT_SIZE];
mArray = (T[]) Array.newInstance(type, size);
count = 0;
}
// 将val添加到栈中
public void push(T val) {
mArray[count++] = val;
}
// 返回“栈顶元素值”
public T peek() {
return mArray[count-1];
}
// 返回“栈顶元素值”，并删除“栈顶元素”
public T pop() {
T ret = mArray[count-1];
count--;
return ret;
}
// 返回“栈”的大小
public int size() {
return count;
}
// 返回“栈”是否为空
public boolean isEmpty() {
return size()==0;
}
// 打印“栈”
public void PrintArrayStack() {
if (isEmpty()) {
System.out.printf("stack is Empty\n");
}
System.out.printf("stack size()=%d\n", size());
int i=size()-1;
while (i>=0) {
System.out.println(mArray[i]);
i--;
}
}
public static void main(String[] args) {
String tmp;
GeneralArrayStack<String> astack = new GeneralArrayStack<String>(String.class);
// 将10, 20, 30 依次推入栈中
astack.push("10");
astack.push("20");
astack.push("30");
// 将“栈顶元素”赋值给tmp，并删除“栈顶元素”
tmp = astack.pop();
System.out.println("tmp="+tmp);
// 只将“栈顶”赋值给tmp，不删除该元素.
tmp = astack.peek();
System.out.println("tmp="+tmp);
astack.push("40");
astack.PrintArrayStack(); // 打印栈
}
/**
*
*
*
* 运行结果：
*
* tmp=30
* tmp=20
* stack size()=3
*
* 40
* 20
* 10
*
* 结果说明：GeneralArrayStack是通过数组实现的栈，而且GeneralArrayStack中使用到了泛型。
*
*/
}
通过链表的形式来创建栈
package com.pingkeke.rdf.sample;
/**
* 我们接下来通过链表的形式来创建栈，方便扩充.
*/
public class Stack01 {
class Node {
int data;
Node pre; // 我们需要知道当前结点的前一个结点
public Node(int data) {
this.data = data;
}
}
public Node head;
public Node current;
/**
* 入栈操作
* @param data
*/
public void push(int data) {
if (head == null) {
head = new Node(data);
current = head;
} else {
Node node = new Node(data);
/**
* 入栈操作时，下面两行代码是关键。
*/
node.pre = current; // current结点将作为当前结点的前驱结点
current = node; // 让current结点永远指向新添加的那个结点
}
}
/**
* 出栈：返回并删除栈顶元素的操作。
* @return
*/
public Node pop() {
if (current == null) {
return null;
}
Node node = current; // current结点是我们要出栈的结点
current = current.pre; // 每出栈一个结点后，current后退一位
return node;
}
public static void main(String[] args) {
Stack01 stack = new Stack01();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop().data);
System.out.println(stack.pop().data);
System.out.println(stack.pop().data);
/**
* 运行结果:
* 3
2
1
*/
}
}
Java的 Collection集合 中自带的"栈"(stack)的示例。
package com.pingkeke.rdf.sample;
import java.util.Stack;
/**
* Java的 Collection集合 中自带的"栈"(stack)的示例.
*/
public class StackTest {
public static void main(String[] args) {
int tmp=0;
Stack<Integer> astack = new Stack<Integer>();
// 将10, 20, 30 依次推入栈中
astack.push(10);
astack.push(20);
astack.push(30);
// 将“栈顶元素”赋值给tmp，并删除“栈顶元素”
tmp = astack.pop();
System.out.printf("tmp=%d\n", tmp);
// 只将“栈顶”赋值给tmp，不删除该元素.
tmp = (int)astack.peek();
System.out.printf("tmp=%d\n", tmp);
astack.push(40);
while(!astack.empty()) {
tmp = (int)astack.pop();
System.out.printf("tmp=%d\n", tmp);
}
}
/**
* 运行结果：
*
* tmp=30
* tmp=20
*
* tmp=40
* tmp=20
* tmp=10
*/
}
使用两个队列实现一个栈
我们先往栈内压入一个元素a。由于两个队列现在都是空，我们可以选择把a插入两个队列中的任一个。我们不妨把a插入queue1。接下来继续网栈内压入b,c两个元素。我们把它们都插入queue1。这个时候 queue1包含3个元素a,b,c其中a位于队列的头部，c位于队列的尾部。
现在我们考虑从栈内弹出一个元素。根据栈的后入先出的原则，最后被压入栈的c应该最先被弹出。由于c位于queue1的尾部，而我们每次只能从队列的头部删除元素，因此我们可以从queue1中依次删除a/b/c并插入到queue2中，再从queue1中删除c。这就相当于从栈中弹出元素c了。我们可以用同样的方法从栈内弹出元素b。
接下来我们考虑从栈内压入一个元素d.此时queue1已经有了一个元素，我们就把d插入到queue1的尾部。如果我们再从栈内弹出一个元素，此时被弹出的应该是最后被压入的d.由于d位于queue1的尾部，我们只能先从头部删除 queue1的元素并插入到queue2，直到queue1中遇到d再直接把它删除。如图所示：
使用两个队列实现一个栈
package com.pingkeke.rdf.sample;
import java.util.LinkedList;
/**
* 两个队列实现一个栈.
*/
public class Stack02 {
private LinkedList<String> queue1 = new LinkedList<String>();
private LinkedList<String> queue2 = new LinkedList<String>();
/**
* 入栈操作
* @param obj
*/
public void push(String obj) {
if(queue1.isEmpty()) {
queue2.add(obj);
}
if(queue2.isEmpty()) {
queue1.add(obj);
}
}
/**
* 出栈操作
* @return
*/
public String pop() {
// 两个栈都为空时,没有元素可以弹出
if (queue1.isEmpty()&&queue2.isEmpty()) {
try {
throw new Exception("stack is empty");
} catch (Exception e) {
}
}
if(queue1.isEmpty()){
while(queue2.size()>1){
queue1.add(queue2.poll());
}
return queue2.poll();
}
if(queue2.isEmpty()){
while(queue1.size()>1){
queue2.add(queue1.poll());
}
return queue1.poll();
}
return null;
}
public static void main(String[] args) throws Exception {
Stack02 stack = new Stack02();
stack.push("a");
stack.push("b");
stack.push("c");
System.out.println(stack.pop());
System.out.println(stack.pop());
stack.push("d");
System.out.println(stack.pop());
}
/**
* 运行结果:
* c
b
d
*/
}
