数据结构二、简单的栈简单点

栈描述

• 栈也是一种线性数据结构
• 规定只能从栈顶添加元素，也只能从栈顶取出元素
• 栈是一种后进先出的数据结构
• 栈就相当于是一个箱子,入栈就是向箱子里面放书,出栈就是从箱子里面取书,因为取书只能取最后一本书,所以栈是一个先进后出的数据结构

创建栈

1.先创建一个栈接口

public interface StackInterface<T> {
    //判断栈有多少元素
    public int getSize();

    //判断栈是否为空
    public boolean isEmpty();

    //入栈
    public void push(T ele);

    //出栈(弹得是栈顶元素)
    public T pop();

    //查看栈顶元素是什么
    public T peek();
}

2.实现栈

• 先声明栈,栈也是一个数组
  • 这里是调用博主自己写的动态数组 来实现栈的
• 在给出栈元素的数量
• 判断栈存了多少元素,只需要返回栈的元素个数即可所以时间复杂度为O(1)
• 判断栈是否为空,同上时间复杂度为O(1)
• 入栈,实际上就是给数组的尾部添加元素,所以时间复杂度为O(1)
  • 但是会有栈满,需要扩容问题
  • 我们使用了均摊复杂度,因为不是每次都需要扩容
  • 均摊后时间复杂度为O(1)
• 出栈,一样是给数组的尾部删除元素,所以时间复杂度为O(1)
• 查看栈顶元素,就是数组的查询数组的尾部元素,所以时间复杂度为O(1)

public class MyStack<T> implements StackInterface<T> {
    //数据容器
    private MyArray<T> data;
    //栈中元素数量
    private int size;

    //构造函数
    public MyStack() {
        data = new MyArray<>();
        size = 0;
    }

    //判断栈有多少元素
    @Override
    public int getSize() {
        return size;
    }

    //判断栈是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //入栈
    @Override
    public void push(T ele) {
        try {
            data.addTail(ele);
            size++;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    //出栈(弹得是栈顶元素)
    @Override
    public T pop() {
        T result = null;
        try {
            result = data.removeTail();
            size--;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return result;
    }

    //查看栈顶元素是什么
    @Override
    public T peek() {
        try {
            return data.getTail();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        result.append("栈中总共存" + size + "元素个数");
        result.append("[");
        try {
            for (int i = 0; i < size; i++) {
                result.append(data.getEleByIndex(i));
                if (i != size - 1) {
                    result.append(",");
                }
            }
            result.append("] 栈顶");
            return result.toString();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }

    }
}

栈的应用

• 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
  有效字符串需满足：
  • 左括号必须用相同类型的右括号闭合。
  • 左括号必须以正确的顺序闭合。

力扣20题

 public boolean isValid(String s) {

        /**
         * 左括号必须用相同类型的右括号闭合。
         * 左括号必须以正确的顺序闭合。
         */
        //             空字符串
        if (s == null || s.isEmpty()) {
            return true;
        }
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            //先入栈,如果是左边的那就入栈
            char lentter = s.charAt(i);
            if (lentter == '{' || lentter == '[' || lentter == '(') {
                stack.push(lentter);
            } else {
                //如果字符串为空,那就是只有一个左边的,入栈了,没出去,那不就直接返回false
                if (stack.isEmpty()) {
                    return false;
                } else {
                    //如果是右边的那就出栈,如果入一个左边的,下一个是他的另一半那就出栈,不是那就返回false
                    char pop = stack.pop();
                    if (lentter == '}' && pop != '{') {
                        return false;
                    } else if (lentter == ']' && pop != '[') {
                        return false;
                    } else if (lentter == ')' && pop != '(') {
                        return false;
                    }
                }
            }
        }
        //上面就开始循环了,是左边的进一个,判断是右边的出一个一直循环,直到循环结束
        //但是还要考虑{{}这种情况,第一个进栈,到第二个进栈,第三个出栈,循环完栈中还有一个'{'
        //这是只需要判断栈是否为空,若为空,说明左右括号都对应出完了不为空,说明少几个有括号返回false
        return stack.isEmpty();
    }