java栈--后进先出（顺序栈、链栈、单词逆序）

栈： 是限定仅在表尾插入和删除操作的线性表，允许插入和删除的一段称为栈顶，另一端为栈底。 栈的特点就是： 后进先出。

栈的实现非常简单，在生活中的也时常应用到，如：表达式求值、函数的调用用栈保存数据、语法的检验、函数的递归实现等都是基于栈的实现。在这里利用一张图就可以清晰的展示栈的操作。对栈的操作时间复杂度都是常数，都是对栈顶元素的操作。

下面是笔者实现的一个顺序栈，利用数组来存放元素。

package org.TT.Stack;

/** 栈：后进先出
 *      栈是一个概念上的辅助工具。这里采用数组完成栈的操作，这里利用泛型，可以参入任何参数对象。
 *      栈的数据项的出栈、入栈时间复杂度为常数 O(1)。
 *
 */
public class Stack<T> {

	private int maxSize;   
	private Object[] stackArray;
	private int top;
	
	// 创建一个指定大小的新栈，并将top指向栈底。
	public Stack(int length){
		maxSize = length;
		stackArray = new Object[maxSize];
		top = -1;
	}
	
	// 入栈，将top值加1，是它指向原栈顶的上面一个位置，并将新的值存入这个位置。（插入前top先加1）
	public void push(T value){
		if(isFull()){
			throw new RuntimeException("栈满！不能插入！");  // 入栈前先判断是否已满
		}
		stackArray[++top] = value;
	}
	
	// 出栈， 返回top 标识的数据，然后减一。pop有效的从栈中移除了数据项，
	// 虽然数据项仍然存在数组中(新的数据项会覆盖旧的数据项)，但不再能访问。
	@SuppressWarnings("unchecked")
	public T pop(){
		if(isEmpty()){
				throw new RuntimeException("栈空！没有元素可取！");   // 出栈前判断栈是否为空
		}
		return (T)stackArray[top--];
	}
	
	// 取得栈定数据项
	@SuppressWarnings("unchecked")
	public T peek(){
		return (T) stackArray[top];
	}
	
	// 判断栈是否为空，top 等于-1 时为空栈
	public boolean isEmpty(){
		return (top == -1);
	}
	
	// 判断栈是否栈满，top 等于maxSize -1 时栈满
	public boolean isFull(){
		return (top == maxSize -1);
	}
	
    @SuppressWarnings("unchecked")
	public T get(int index) {   
        return (T) stackArray[index];   
    } 
	
    public void display(String str) {   
        System.out.print(str);   
        System.out.print(" Stack (bottom-->top): ");   
        for (int i = 0; i < maxSize; i++) {   
            System.out.print(get(i)+" ");   
        }   
        System.out.println();   
    }
	
    // 测试 栈
	public static void main(String[] args) {
		Stack<String> stack = new Stack<>(5);
		stack.push("a");
		stack.push("b");
		stack.push("c");
		stack.push("d");
		stack.push("e");
		
		while(!stack.isEmpty()){           // 依次出栈
			String value = stack.pop();
			System.out.print(value + " ");
		}
	}
}

接下来笔者又用链接存储结构实现了一个-- 链栈。通常采用 单链表实现链栈，用单链表的头部做栈顶是最方便的，因为只能栈链栈的栈顶插入删除。

在这里，笔者采用前面说实现的 SingleLinkedList ，笔者可以参见前面的讲解，以下只是对链表进行了一次封装，进而实现了链栈。相信读者也能轻松理解栈的思想。

package org.TT.Stack;

import org.TT.LinkedList.Node;
import org.TT.LinkedList.SingleLinkedList;

public class LinkStack<T> {

	private SingleLinkedList<T> linkList;
	
	public LinkStack(){
		linkList = new SingleLinkedList<>();
	}
	
	public boolean isEmpty(){
		return linkList.isEmpty();
	}
	
	public void push(T item){
		linkList.insertFirst(item);
	}
	
	public Node<T> pop(){
		return linkList.removeFirst();
	}
	
	public Node<T> peek(){
		return linkList.getFirst();
	}
	
	public int stackSize(){
		return linkList.getSize();
	}
	
	public void displayStack(){
		linkList.printList();
	}
	
	public static void main(String[] args) {
		LinkStack<String> linkStack = new LinkStack<>();
		linkStack.push("A");
		linkStack.push("B");
		linkStack.push("C");
		
		System.out.println("查看栈顶：" + linkStack.peek().getNodeValue());
		
		System.out.println("栈的大小: " + linkStack.stackSize());
		
		System.out.println("栈顶（C）出栈： " + linkStack.pop().getNodeValue());
		
		System.out.print("C出栈后的栈：");
		linkStack.displayStack();
		
		// 进栈顺序 为 A、B、C 然后 把栈顶元素出栈（此时为：C）， 所以再依次出栈为： B、 A
	}
	
}

下面给读者带来一个应用： 单词逆序。 将输入的单词，逆序输出，入输入abcd， 得到的结果就是dcba。 这个就是应用栈的思想， 先将输入的单词分成字母，并将得到的字母分别压入栈中，在将字母分别出栈，并拼接成原来单词的逆序。

package org.TT.Stack;

import java.util.Scanner;

/** 你用栈实现  单词逆序
 */
public class WordReversed {

	private String input;
	private String output;
	
	public WordReversed(String in) {
		input = in;
	}
	
	public String reversed(){
		output = "";
		int stackSize = input.length();
		Stack<String> stack = new Stack<>(stackSize);
		
		String str[] = input.split("");
		
		for(int i = 0; i <input.length(); i++){
			String ch = str[i];
			stack.push(ch);               // 将单词依次压栈，先进的单词就到了栈底，后进的在栈顶。
		}
		
		while(!stack.isEmpty()){
			String ch = stack.pop();  // 将单词依次弹出栈，并保持每次弹出的数据项。
			output = output + ch;   // 先弹出栈顶（后进单词），所有顺序颠倒
		}
		
		return output;
	}
	
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		
		String input, output;
		
		while(true){
			System.out.println("请输入字符串：");
			Scanner in = new Scanner(System.in);
			input = in.nextLine();
			
			WordReversed reversed = new WordReversed(input);
			output = reversed.reversed();
			System.out.println("逆序为： " + output);
			
		}
		
	}
	
}

如图：      

下面我们来简单说明一下，顺序栈和链栈的区别：顺序栈和链栈的操作的时间复杂度都是常数，但是顺序栈初始化时必须确认一个固定的长度，对于存储元素是有限制，并且还有可能浪费存储空间；链栈则没有栈满的情况，除非内存不足，当不确定元素个数是优先选择链栈。