栈的详解.

---

栈的基本概念

定义
 只允许在一端进行插入或删除操作的线性表。首先，栈是一种线性表，但限定这种线性表只能在某一段进行插入和删除操作。

采用顺序存储的栈称为顺序栈，它是利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶的位置。
采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头结点，top指向栈顶元素，
基础概念
 栈顶（Top）：线性表允许进行插入和删除的一端。
 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
 空栈：不含任何元素。

栈的应用

①改进递归代码
②实现表达式等
③模拟实现

题型1 , 实现栈

package NiuKe.StackandQueqe;

import java.util.Arrays;

public class my_Stack {
    // 栈用什么来实现吧 ,  数组
   int[] elem ;
   int size;
   public my_Stack(int size){
       elem = new int[size];
   }
    public my_Stack(){
       elem = new int[10];
    }

   public void initStack(int[] array){
       elem =Arrays.copyOf(array,elem.length);
       size = Math.min(array.length,elem.length);
   }
   //入栈
   public void push(int val){
       if (isFull()){
           elem = Arrays.copyOf(elem,elem.length*2);
       }
       elem[size++] = val;
   }
   //出栈
   public int  pop(){
       if (isEmpty()){
           throw new RuntimeException("栈为空,没有元素错误");
       }
       int k = --size;

       return elem[k];
   }
//   判断栈是否空
   public boolean isEmpty(){
       return size == 0;
   }
//   判断栈是否满
   public boolean isFull(){
       return size == elem.length;
   }


    public static void main(String[] args) {
        //测试代码
        int[] arr = {1,3,5,7,5};
        my_Stack stack =new my_Stack();
        for (int i = 0; i < arr.length; i++) {
            stack.initStack(arr);
        }
        int size =stack.size;
        for (int i = 0; i < size; i++) {
            System.out.println(stack.pop());
        }
    }
}

包含min函数的栈

描述 : 定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的 min 函数，输入操作时保证 pop、top 和 min 函数操作时，栈中一定有元素。

此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素

import java.util.Stack;

public class Solution {

    
   Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    public void push(int node) {
        stack1.push(node);
    }

    public void pop() {
        if (stack1==null)return;
        stack1.pop();
    }

    public int top() {
        if (stack1==null)return -1;
        return stack1.peek();
    }

    public int min() {
        if (stack1==null)return -1;
        int min=Integer.MAX_VALUE;
        while (!stack1.isEmpty()){
            int a=stack1.pop();
            if (min>a)min=a;
            stack2.push(a);
        }
        while (!stack2.isEmpty()){
            int a=stack2.pop();
            stack1.push(a);
        }
        return min;
    }
}

用俩个栈实现队列

描述 : 用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);

    }

    public int pop() {
        if (stack1==null)return -1;
        while (!stack1.isEmpty()){
            int a=stack1.pop();
            stack2.push(a);
        }
        int count=stack2.pop();
        while (!stack2.isEmpty()){
            int a=stack2.pop();
            stack1.push(a);
        }
        return count;
    }
}

题型2 : 有效括号序列

描述 : 给出一个仅包含字符’(‘,’)‘,’{‘,’}‘,’[‘和’]',的字符串，判断给出的字符串是否是合法的括号序列括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。

import java.util.*;


public class Solution {
    /**
     * 
     * @param s string字符串 
     * @return bool布尔型
     */
   public boolean isValid (String s) {

       if (s==null)return false;
       Stack<Character> stack1 = new Stack<Character>();
       for (int i = 0; i < s.length(); i++) {
           if(s.charAt(i) == '(') stack1.push(')');
           else if(s.charAt(i) == '[') stack1.push(']');
           else if(s.charAt(i) == '{') stack1.push('}');
           else if(stack1.isEmpty() || stack1.pop() != s.charAt(i))
               return false;
       }
      return stack1.isEmpty();
   }
}

实现计算器

请写一个整数计算器，支持加减乘三种运算和括号。

import java.util.*;

public class Solution {
    // 使用 map 维护一个运算符优先级（其中加减法优先级相同，乘法有着更高的优先级）
    Map<Character, Integer> map = new HashMap<Character, Integer>(){{
        put('-', 1);
        put('+', 1);
        put('*', 2);
    }};

    public int solve(String s) {
        // 将所有的空格去掉
        s = s.replaceAll(" ", "");

        char[] cs = s.toCharArray();
        int n = s.length();

        // 存放所有的数字
        Deque<Integer> nums = new ArrayDeque<>();
        // 为了防止第一个数为负数，先往 nums 加个 0
        nums.addLast(0);
        // 存放所有「非数字以外」的操作
        Deque<Character> ops = new ArrayDeque<>();

        for (int i = 0; i < n; i++) {
            char c = cs[i];
            if (c == '(') {
                ops.addLast(c);
            } else if (c == ')') {
                // 计算到最近一个左括号为止
                while (!ops.isEmpty()) {
                    if (ops.peekLast() != '(') {
                        calc(nums, ops);
                    } else {
                        ops.pollLast();
                        break;
                    }
                }
            } else {
                if (isNumber(c)) {
                    int u = 0;
                    int j = i;
                    // 将从 i 位置开始后面的连续数字整体取出，加入 nums
                    while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
                    nums.addLast(u);
                    i = j - 1;
                } else {
                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
                        nums.addLast(0);
                    }
                    // 有一个新操作要入栈时，先把栈内可以算的都算了 
                    // 只有满足「栈内运算符」比「当前运算符」优先级高/同等，才进行运算
                    while (!ops.isEmpty() && ops.peekLast() != '(') {
                        char prev = ops.peekLast();
                        if (map.get(prev) >= map.get(c)) {
                            calc(nums, ops);
                        } else {
                            break;
                        }
                    }
                    ops.addLast(c);
                }
            }
        }
        // 将剩余的计算完
        while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);
        return nums.peekLast();
    }
    // 计算逻辑：从 nums 中取出两个操作数，从 ops 中取出运算符，然后根据运算符进行计算即可
    void calc(Deque<Integer> nums, Deque<Character> ops) {
        if (nums.isEmpty() || nums.size() < 2) return;
        if (ops.isEmpty()) return;
        int b = nums.pollLast(), a = nums.pollLast();
        char op = ops.pollLast();
        int ans = 0;
        if (op == '+') ans = a + b;
        else if (op == '-') ans = a - b;
        else if (op == '*') ans = a * b;    
        nums.addLast(ans);
    }
    boolean isNumber(char c) {
        return Character.isDigit(c);
    }
}