数据结构---手写栈

1. 概述

1. 基础功能和jdk提供的一致。
2. 使用到的Array数组，在上一篇“数据结构–手写动态数组”中已定义。
3. 栈：是“后进先出”的数据结构，所有的操作只能在栈顶操作。

2. 源码

public interface Stack<E> {

    void push(E element);

    E pop();

    E peek();

    int getSize();

    boolean isEmpty();
}



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

    private Array<E> array;


    public ArrayStack() {
        array = new Array<>();
    }

    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }

    @Override
    public void push(E element) {
        array.addLast(element);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.get(array.getSize() - 1);
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        int arraySize = array.getSize();
        result.append(String.format("Stack's size: %d, capacity: %d\n", arraySize, array.getCapacity()));
        result.append("[");
        for (int i = 0; i < arraySize; i++) {
            result.append(array.get(i));
            if (i != arraySize - 1) {
                result.append(", ");
            }
        }

        result.append("] Top");
        return result.toString();
    }
}

3. LeetCode问题

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * LeetCode 20: 有效的括号
 * 题目:
 * 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
 * <p>
 * 有效字符串需满足：
 * <p>
 * 左括号必须用相同类型的右括号闭合。
 * 左括号必须以正确的顺序闭合。
 * 注意空字符串可被认为是有效字符串。
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/valid-parentheses
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
class Solution {
    public boolean isValid(String s) {
        int dataLength = s.length();
        if ("".equals(s.trim())) {
            return true;
        }
        
        if(dataLength % 2 != 0) {
            return false;
        }
        
        Map<Character, Character> rightPattern = new HashMap<>();
        rightPattern.put('}', '}');
        rightPattern.put(')', ')');
        rightPattern.put(']', ']');

        Map<Character, Character> leftPattern = new HashMap<>();
        leftPattern.put('(', '(');
        leftPattern.put('{', '{');
        leftPattern.put('[', '[');

        Map<Character, Character> pattern = new HashMap<>();
        pattern.put('{', '}');
        pattern.put('(', ')');
        pattern.put('[', ']');

        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < dataLength; i++) {
            Character charAt = s.charAt(i);
            Character left = leftPattern.get(charAt);
            Character right = rightPattern.get(charAt);
            if (left == null && right != null) {
                if (stack.empty()) {
                    return false;
                }
                
                Character pop = stack.pop();
                Character patternValue = pattern.get(pop);
                if (right.equals(patternValue)) {
                    continue;
                }

                return false;
            } else {
                stack.push(charAt);
            }
        }
        
        return stack.empty();
    }
}