数据结构与算法之栈

(一) 栈

定义

栈是一种线性序列结构, 它的特殊之处在于, 栈对于其中的元素的访问做了限制, 只能从序列的某一端(栈顶)进行读写操作, 而禁止操作的另一端(栈底). 栈是一种后进先出的数据结构. 相比较数组, 栈对应的操作是数组的子集.
栈的应用应用很广泛, 如: 撤销操作, 程序调用的系统栈等.

(二) 栈的基本实现

基于<<数据结构与算法之数组>>中的动态数组实现

1.新建接口Stack

public interface Stack<E> {

	/**
	 * 获取栈中的有效元素个数
	 * 
	 * @return
	 */
	int getSize();

	/**
	 * 返回栈中有效元素是否为空
	 * 
	 * @return
	 */
	boolean isEmpty();

	/**
	 * 向栈(栈顶)中添加元素
	 * 
	 * @param e
	 */
	void push(E e);

	/**
	 * 从栈(栈顶)中取出元素
	 * 
	 * @return
	 */
	E pop();

	/**
	 * 查看栈顶元素
	 * 
	 * @return
	 */
	E peek();
}	

2.自定义ArrayStack类实现Stack接口

public class ArrayStack<E> implements Stack<E>{

	/**
	 * 动态数组
	 */
	private Array<E> array;
	
	/**
	 * 空构造函数, 穿件容量为10构造动态数组Array
	 * 
	 * @param capacity
	 */
	public ArrayStack() {
		array = new Array<>();
	}
	
	/**
	 * 构造函数, 传入容量capacity构造动态数组Array
	 * 
	 * @param capacity
	 */
	public ArrayStack(int capacity) {
		array = new Array<>(capacity);
	}

	/**
	 * 获取栈中的有效元素个数
	 */
	@Override
	public int getSize() {
		return array.getSize();
	}

	/**
	 * 返回栈中有效元素是否为空
	 */
	@Override
	public boolean isEmpty() {
		return array.isEmpty();
	}

	/**
	 * 获取栈的容量
	 * 
	 * @return
	 */
	public int getCapacity() {
		return array.getCapacity();
	}
	
	/**
	 * 向栈(栈顶)中添加元素
	 */
	@Override
	public void push(E e) {
		array.addLast(e);
	}

	/**
	 * 从栈(栈顶)中取出元素
	 * 
	 * @return
	 */
	@Override
	public E pop() {
		return array.removeLast();
	}

	/**
	 * 查看栈顶元素
	 */
	@Override
	public E peek() {
		return array.getLast();
	}
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append("Statck: ");
		res.append("[");
		for (int i = 0; i < array.getSize(); i++) {
			res.append(array.get(i));
			if(i != array.getSize() - 1) {
				res.append(", ");
			}
		}
		res.append("] Top");
		return res.toString();
	}
}

测试

public static void main(String[] args) {
	ArrayStack<Integer> stack = new ArrayStack<>();
	// 依次向栈(栈顶)中添加元素: 0-4
	for (int i = 0; i < 5; i++) {
		stack.push(i);
		System.out.println(stack);
	}
	// 从栈(栈顶)中取出元素
	stack.pop();
	System.out.println(stack);
}

Top 代表栈顶方向

(三) 栈的应用: 括号比配

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
 
来源：力扣（LeetCode）
链接: https://leetcode-cn.com/problems/valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路: 使用栈数据结构, 每逢左括号则压栈, 每逢右括号则出栈与其对应的左括号匹配, 匹配成功则继续, 否则返回false无效. 最后栈为空则返回true, 反之返回false. 栈顶元素反映了在嵌套的层次关系中, 最近的需要匹配的元素.

import java.util.Stack;

class Solution {
    public boolean isValid(String s) {
		Stack<Character> stack = new Stack<>();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c == '(' || c == '[' || c == '{') {
				// 每逢左括号则压栈
				stack.push(c);
			} else {
				// 栈为空的情况下, 每逢右括号则返回false
				if(stack.isEmpty()) {
					return false;
				}
                // 每逢右括号则出栈与其对应的左括号匹配, 匹配成功则继续, 否则返回false无效
				char topChar = stack.pop();
				if(c == ')' && topChar != '(' || c == ']' && topChar != '[' || c == '}' && topChar != '{') {
					return false;
				}
			}
		}
		return stack.isEmpty();
    }
}