4. 栈

栈

基本都是参考这个up主，非常感谢

1. 相关概念：

栈是一个先入后出（FILO：First In Last Out）的有序列表。

栈（Stack）是限制线性表中元素的插入和删除只能在同一端进行的一种特殊线性表。

允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶

而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

2. 栈的四种功能

1. 访问(Access)：O(1)

栈仅仅只访问栈顶元素

2. 搜索(Search)：O(N)

从头到尾

3. 插入(Insert)： O(1)

只能栈顶插入

4. 删除(Delete)：O(1)

只能删除栈顶元素

3.常用操作

1.创建栈stack

2.添加元素

push()

3.获取栈顶元素

peek()

4.删除栈顶元素

pop()

5.栈的大小

size()

6.栈是否为空

isEmpty()

7.栈的遍历

边删除边遍历

4.Leetcode

20.有效的括号

1. 先判断字符串的长度是否为0，是的话返回true（题目说空字符串也可以）

2. 初始化一个栈

3. 遍历给的字符串的每一个字符

   如果是括号的左边部分，加入栈中

   否则

   ​ 如果栈的长度是0（栈空了），返回false—–》(表示有右边符号但是左边符号没有)

   ​ 否则(如果有左边符号) 创建一个临时指针存放要删除的栈顶元素

   ​ 如果当前的字符是右括号

   ​ 如果弹出的不是左括号，返回false

   最后如果栈空返回true

class Solution {
    public boolean isValid(String s) {
        if (s.length() == 0) {
            return true;
        }
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) { //toCharArray()将字符串转换为字符数组
            if (c == '(' || c == '{' || c == '[') {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                } else {
                    char temp = stack.pop();
                    if (c == ')') {
                        if (temp != '(') {
                            return false;
                        }
                    } else if (c == '}') {
                        if (temp != '{') {
                            return false;
                        }
                    } else if (c == ']') {
                        if (temp != '[') {
                            return false;
                        }
                    }
                }
            }

        }
        return stack.isEmpty() ? true : false;
    }
}

第二种方法（推荐）：

​ 将右边括号入栈

​ 相同的话右边元素出栈，直到栈为空，说明true

public class Leetcode20 {
    public boolean isValid(String s) {
        if (s.length() == 0) {
            return true;
        }
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (c == '(') {
                stack.push(')');
            } else if (c == '{') {
                stack.push('}');
            } else if (c == '[') {
                stack.push(']');
            } else if (stack.empty() || c != stack.pop()) {
                return false;
            }
        }
        //循环完了 如果是空说明正确了 否则false
        return stack.empty();
    }
}

解惑：

​ 第二种方法一直不太清楚是怎么就把栈里面的元素弹出去了

​ 后来意识到在判断stack.empty() || c != stack.pop()的同时就进行了弹栈的操作

496.下一个最大元素

运用了两个栈，一个栈存放当前的数组元素，另一个临时栈存放弹出的元素

public class LeetCode496 {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] res = new int[nums1.length];
        Stack<Integer> stack = new Stack<>();
        for (int nums : nums2) {
            stack.push(nums);
        }
        for (int i = 0; i < nums1.length; i++) {
            Stack<Integer> temp = new Stack<>();
            Boolean flag = false;
            int cur = nums1[i];
            int max = -1;
            while (!stack.isEmpty() && !flag) {
                int top = stack.pop();
                if (top > cur) {
                    max=top;
                }else if (top==cur){
                    flag=true;
                }
                temp.push(top);
            }
            res[i]=max;
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
        return res;
    }
}

此题目前还在研究中