数据结构-栈

栈

栈作为一种后进先出的抽象数据类型，相对于数组而言访问其元素更加受限，这体现在数组只需要知道某个元素下标即可直接访问，或者遍历获取所有元素；而栈只允许访问一个数据项，即每次只能访问栈顶的元素，移除栈顶元素后，才能访问倒数第二个元素。

代码实现

我们可以用java代码模拟栈结构

/**
 * 栈
 * @author sunyan
 *
 */
public class Stack {
	private int[] stackArray;
	private int maxSize;//最大容积
	private int top;//下标
	
	public Stack(int size){
		this.maxSize = size;
		this.stackArray = new int[maxSize];
		this.top = -1;
	}
	
	/**
	 * 入栈
	 * @param x
	 */
	public void push(int x){
		stackArray[++top] = x;
	}
	
	/**
	 * 出栈
	 * @return
	 */
	public int pop(){
		return stackArray[top--];
	}
	
	/**
	 * 栈顶元素
	 * @return
	 */
	public int peek(){
		return stackArray[top];
	}
	
	/**
	 * 栈是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return (top == -1);
	}
	
	/**
	 * 栈是否已满
	 * @return
	 */
	public boolean isFull(){
		return (top == maxSize);
	}
}

这里实现了栈的几个基本功能，然后我们向栈中加入几个元素来模拟出栈

public class StackTest {
	public static void main(String[] args){
		Stack stack = new Stack(5);
		stack.push(0);
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		while(!stack.isEmpty()){
			System.out.print(stack.pop());
		}
	}
}

输出结果：

可以看到，后插入的元素先输出。

栈的应用场景之一

利用栈实现字符串的逆序

public class Stack {
	private char[] chars;
	private int maxSize;
	private int top;
	
	public Stack(int size){
		this.maxSize = size;
		this.chars = new char[maxSize];
		this.top = -1;
	}
	
	public void push(char c){
		chars[++top] = c;
	}
	
	public char pop(){
		return chars[top--];
	}
	
	public boolean isEmpty(){
		return (top == -1);
	}
}

/**
 * 利用栈实现字符串逆序
 * @author sunyan
 *
 */
public class ReverseWordsTest {
	public static void main(String[] args){
		String str = "abcde";
		char[] chars = str.toCharArray();
		
		Stack stack = new Stack(5);
		for(char c : chars){
			stack.push(c);
		}
		
		while(!stack.isEmpty()){
			System.out.print(stack.pop());
		}
	}
}

输出结果为：

栈的应用场景之二

分隔符匹配检查

public class Stack {
	private char[] chars;
	private int maxSize;
	private int top;
	
	public Stack(int size){
		this.maxSize = size;
		this.chars = new char[maxSize];
		this.top = -1;
	}
	
	public void push(char c){
		chars[++top] = c;
	}
	
	public char pop(){
		return chars[top--];
	}
	
	public boolean isEmpty(){
		return (top == -1);
	}
}

/**
 * 利用栈检查 分隔符是否匹配
 * 比如 {1[2]3} ： 匹配
 *     「a」{]  :不匹配
 * 
 * 分析：分隔符分为 左分隔符、右分隔符. 左右分隔符必须相互匹配。且后出现的左分隔符对应先出现的右分隔符，如1 中的[对应先出现的有分隔符].
 *      因此可以将左分隔符入栈，当出现有分隔符时 做出栈操作，看是否与出栈的分隔符匹配。
 * @author sunyan
 *
 */
public class BracketsTest {
	public static void main(String[] args){
		
		String str = "{{ab}[(cd)e]";
		char[] charArray = str.toCharArray();
		Stack stack = new Stack(str.length());
		for(int i = 0; i < charArray.length; i++){
			char ch = charArray[i];
			switch (ch){
			case '{':
			case '[':
			case '(':
				stack.push(ch);
				break;
			case '}':
			case ']':
			case ')':
				if(!stack.isEmpty()){
					if(ch=='}'&&stack.pop()!='{' || (ch==']'&&stack.pop() != '[') || (ch==')'&&stack.pop()!='(')){
						System.out.println("左右分隔符不匹配");
					}
				}else{
					System.out.println("没有左分割字符与之匹配");
				}
				break;
			default:
					break;
			}
		}
		if(!stack.isEmpty()){
			System.out.println("没有右分割字符与之匹配");
		}
	}
}

输出结果为：