栈及其简单应用 （1）

       栈，是一种线性数据结构，比起数组而言，栈对应的操作较少，栈只能从一端添加元素，也只能从此端取出元素。栈是种后进先出的数据结构。它类似于弹夹中子弹，先进的后出来，而后进的却先出来。

       在栈中，允许插入和删除的一端被栈顶，另一端被称为栈底，不含任何数据元素的栈被称为空栈。栈又称为后进先出（Last  In First Out）的线性表，简称LIFO结构。

       栈的操作方法

package com.hqw;

public interface Stack<E> {

    void push(E value);
    E pop();
    E peek();
    int getSize();
    boolean isEmpty();
}

       基于封装的数组类，对栈的操作的实现

package com.hqw.stack;

import com.hqw.array.Array;

/**
 * @author hqw521@qq.com
 * @date 2018/6/5 10:26
 */
public class ArrayStack<E> implements Stack<E> {
    private Array<E> array;
    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }
    public ArrayStack() {
        array = new Array<>();
    }

    /**
     * 获取队列容量
     * @return
     */
    public int getCapacity() {
        return array.getCapacity();
    }

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

    /**
     * 查看是否为空栈
     * @return
     */
    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    /**
     * 入栈
     * @param value
     */
    @Override
    public void push(E value) {
        array.addLast(value);
    }

    /**
     * 出栈
     * @return
     */
    @Override
    public E pop() {
        return array.removeLast();
    }

    /**
     * 查看栈顶元素
     * @return
     */
    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("stack: top: [");
        for (int i = getSize() - 1; i >= 0; i--) {
            res.append(array.get(i));
            if (i != 0) {
                res.append(", ");
            }
        }
        res.append("]");
        return res.toString();
    }
}

    栈的简单应用——括号匹配（选自LeetCode）

   题目：

                Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

                 An input string is valid if:

                     1. Open brackets must be closed by the same type of brackets.

                     2. Open brackets must be closed in the correct order.

                 Note that an empty string is also considered valid

   解答：

        为了减少代码量，所以我就使用了Java中Stack类，并未使用自己实现的栈

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 {
                if (stack.isEmpty())
                    return false;
                char topChar = stack.pop();
                if (c == ')' && topChar != '(')
                    return false;
                else if (c == '}' && topChar != '{')
                    return false;
                else if (c == ']' && topChar != '[')
                    return false;
            }
        }
        if (stack.isEmpty())
            return true;
        return false;
    }
}