数据结构--栈和队列（上）

一丶关于栈的定义以及基本方法

首先，什么是栈呢？
我们中国的汉字–栈：储存货物或供旅客住宿的房屋，这是对于它的解释。那么同理，其实在编程中的栈也就是储存元素数据的一种数据结构。
我们从数据结构的角度看的话，栈其实就是一种操作受限的线性表。
其只能在一端进行插入和删除工作，这一端叫做栈顶，相反的一端叫栈底。
我们把一个元素进栈叫做进栈，入栈或者压栈。我们把一个元素出栈叫做出栈或者退栈。

可以看到，栈的底部是封住的，这意味着什么？
$后进先出$
因为后面进的反而在上面，出去也是他们先出去。
那么栈到底是用来干什么呢？栈是当函数被调用的时候用来储存断点的。一般递归的时候用到栈的话会方便很多。
在计算机系统当中，所谓栈就是一个动态内存区域。程序可以将数据压入栈中，也可以将数据从栈顶弹出。每一次压栈都会将栈顶的地址减小，而每一次出栈都会将栈顶的地址增大。最重要的是栈保存了一个函数调用时所需要的维护信息。这常常称之为堆栈帧或者活动记录。
这里有一个点需要说明一下：

栈刚开始创建的时候，是有一个初始大小的，但是后续随着栈元素的压栈，它会慢慢扩容。

那么对于栈的操作其实也很简便，主要有以下几种方法：

Stack() 构造一个空的栈
E push(E e) 将e入栈，并返回e
E pop() 获取栈顶元素
E peek() 将栈顶元素出栈并返回
int size() 获取栈中有效元素个数
boolean empty() 检测栈是否为空

二丶关于栈的使用

关于递归

比如我们在之前写过一篇博客关于链表的反转打印：
关于链表的反转
如果我们在之前想要逆序打印一个链表的话那就只有先反转一个链表然后再遍历。但是如果有了栈的话，就能方便很多。

//首先检测链表不为空格
void printList(Node node){
 if(null == node){
 return;
 }
 //构建一个栈
 Stack<Node> s = new Stack<>();
 // 将链表中的结点保存在栈中
 Node cur = node;
 while(null != cur){
 s.push(cur);
 cur = cur.next;
 }
 
 // 将栈中的元素出栈
 while(!s.empty()){
 System.out.print(s.pop().val + " ");
 }
}

括号匹配

具体题目来源:
有效的括号

具体题目如上。
思路：如果遇到左括号就入栈，如果遇到右括号就出栈进行匹配对比看是否匹配。

解答代码如下：

class Solution {
     public boolean isValid(String s) {
     	//先创建一个栈，然后等下用来操作
        Stack<Character> stack = new Stack<>();
        //把输入字符串开始进行一个一个的分割
        for(int i = 0;i < s.length();i++){
            char fac = s.charAt(i);
            //如果是左括号，就压栈
            if(fac == '[' ||
                    fac == '{' ||
                    fac == '('  ){
                stack.push(fac);
            }
            //如果是右括号，就进行判断
            else{
            	//这个时候如果栈为空，那么就直接是false
                if(stack.empty()){
                    return false;
                }
                char top = stack.peek();
                //如果能匹配就是true
                if((top == '[' && fac == ']')||
                        (top == '{' && fac == '}')||
                        (top == '(' && fac == ')') ){
                    stack.pop();
                    continue;
                }
                //如果不匹配就是false
                else{
                    return false;
                }
            }
        }
        //最后判断栈是否为空，如果不为空，那么还是返回false
        if(!stack.empty()){
            return false;
        }
        return true;
    }
}

逆波兰表达式求值

那么其实在之前我们说过一个概念：taken序列。也就是语法树的前身，在这里的这个逆波兰表达式也是token序列的一种。
我们平常看到的式子一般都是中缀表达式：

7 *(4 + 2)，这是把运算符号放在了运算数之间

但是后缀表达式，也就是逆波兰表达式，是这个样子的。

7 4 2 + *，也就是说，逆波兰表达式是把运算符号放在了运算数之后

在这里呢，有一道OJ题，然后用这个OJ题来进行叙述：
来源：逆波兰表达式求值
解答如下：

public static int evalRPN(String[] tokens) {
		//先定义栈
        Stack<Integer> stack = new Stack<>();
        //然后遍历元素
        for(int i = 0;i < tokens.length;i++){
            if(tokens[i].equals("+")){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a+b);
            }
            else if(tokens[i].equals("-")){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b-a);
            }
            else if(tokens[i].equals("*")){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a*b);
            }
            else if(tokens[i].equals("/")){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b/a);
            }
            //如果不是加减乘除那就入栈，并且使用valueOf方法进行数字化
            else{
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        Integer key = Integer.valueOf(stack.pop());
        return key;
    }

出栈入栈次序匹配

在这里的话呢，首先抛一道选择题。

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2 。 B: 2,3,4,1。 C: 3,1,4,2。 D: 3,4,2,1。

可以发现是C，因为如果想要3出栈，那么就先要入栈，但是入栈顺序只能是1 2 3 4，所以入栈 1 2 3，然后3出栈，接下来要出栈1，但是1上面压了一个2，很明显没有办法出栈，所以C不可能。

那么我们能不能写一个代码，来对这一类题进行判断呢？
题目来源：
栈的压入，弹出序列

具体解答：

 public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack= new Stack();
                
        int puLdx = 0;//这里定义压栈序列下标
        int poLdx = 0;//这里定义出栈序列下标

        //检测出栈序列下标不能越界
        while(poLdx < popped.length){
            //入栈条件：栈为空或者栈顶元素和出栈序列当前下标元素不同
        while(stack.empty() || popped[poLdx] != stack.peek()){
            if(puLdx < pushed.length){
                stack.push(pushed[puLdx]);
                puLdx++;
            }else{
                return false;
            }
        }
        //如果栈顶元素和出栈序列当前下标元素相同那么出栈，并且下标加一
        if( popped[poLdx] == stack.peek()){
            stack.pop();
            poLdx++;
        }
        }
        //最后判断成立条件
        if(puLdx == poLdx){
            return true;
        }
        return false;
    }

三丶栈的模拟实现

一般来说，栈有两种，第一种就是上面我们一直用的，底层是特殊的顺序表。还有一种底层是链表的，但是在这里我们先暂时不对它进行讨论。我们这一部分来实现一下底层是顺序表的这种栈，当然也是阉割版的。

import java.util.Arrays;

public class Stack<E>{
    E[] array;
    int size;

    public Stack(){
        array = (E[])new Object[3];//会直接初始化一个初始容量被
        size = 0;
    }

    //压栈的方法
    public void push(E e){
        ensureCapacity();//首先要扩容吧

        array[size] = e;
        size++;
    }
    //扩容方法
    public void ensureCapacity(){
        if(size >= array.length){
            int old = array.length;
            array = Arrays.copyOf(array,old * 2);
        }
    }

    //取出栈顶元素，就是直接删除
    public E pop(){
        E e = array[size - 1];
        size--;
        return e;
    }

    public E peek(){
        if(size == 0){
            throw new NullPointerException("栈是空的");
        }

        return array[size - 1];
    }

    //判断是否为空
    public boolean empty(){
        return size == 0;
    }

    public String toString(){
        String s = "[";
        for(int i = size - 1;i > 0;i--){
            s += array[i] + ",";
        }
        s += array[0] + "]";
        return s;
    }
    //开始测试
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(0);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack);

        stack.pop();
        System.out.println(stack);

        stack.peek();
        System.out.println(stack);

        System.out.println(stack.size);
        System.out.println(stack.empty());
    }

}

具体运行结果如下：
也全都正确。

四丶总结

刷题刷题刷题！！！！！