数据结构-栈

小曾学java

已于 2023-09-09 23:45:56 修改

阅读量575

点赞数 4

文章标签：数据结构

于 2023-09-09 23:41:55 首次发布

本文链接：https://blog.csdn.net/small_ze_career/article/details/132688899

版权

本文详细介绍了栈的结构及其在现实中的应用，通过模拟实现栈的基本操作，包括入栈、出栈、获取栈顶元素和判空。此外，还涉及了与栈相关的面试题，如逆序打印链表、有效括号验证和逆波兰表达式的计算。

摘要由CSDN通过智能技术生成

一、理解栈的结构

现实生活中的例子：存放书本的箱子

下面我用模拟一下我们拿书的过程：

现在我们要拿三国演义这本书：

第一步：取出水浒传，放一边

第二步：取出西游记，放一边

第三步：取出三国演义

第四步：把西游记和水浒传放回书箱内

栈的结构：

栈的结构，跟上述的书箱子一样，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

如图：

二、模拟实现栈

1.基本框架

public class MyStack {

    //创建一个数组实现栈
    private int[] data;

    //表示栈的元素个数，也可以表示栈顶
    int top;

    //设置默认容量
    private static final int DEFAULTCAPACITY = 10;

    //构造方法
    public MyStack(){
        data = new int[DEFAULTCAPACITY];
        top = 0;
    }

    //入栈
    public void push(int val){

    }

    //出栈
    public int pop(){

    }

    //获取栈顶元素
    public int peek(){

    }

    //判空
    public boolean empty(){

    }

}

2.入栈(push)

示例图

代码

    //入栈
    public void push(int val){
        if (top == data.length){
            //扩容
            data = Arrays.copyOf(data,data.length*2);
        }
        //插入元素，并且top++一下
        data[top++] = val;
    }

3.出栈

示例图

代码

    //出栈
    public int pop(){
        //如果此时栈的数据个数为0，则返回-1
        if (top == 0){
            return -1;
        }else{//如果不为0，则top--，并返回刚刚删除的元素
            top--;
            return data[top];
        }
    }

出栈这里要注意，实际上并没有真正把栈顶元素删除，只是把top往下挪了一格，这样就无法访问到原来栈顶的元素，可以被认为已经删除此元素了

4.获取栈顶元素

代码

    //获取栈顶元素
    public int peek(){
        //如果此时栈的数据个数为0，则返回-1
        if (top == 0){
            return -1;
        }else{//如果不为0,则只需要返回top-1位置的数据
            return data[top - 1];
        }
    }

这里要注意，要获取栈顶元素，访问的是数组top-1下标位置的元素

5.判空

代码

    //判空
    public boolean empty(){
        return top == 0;
    }

三、面试题

1.逆序打印链表：

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路(利用栈的特性)

例如以下链表：

第一步：创建一个栈

第二步：将链表结点的数据从头到尾依次入栈

入栈后如图：

第三步：再从栈顶开始出栈，放入一个新的数组中

代码

    public int[] reversePrint(ListNode head) {
        //创建一个栈

        Stack<Integer> stack = new Stack<>();

        //将链表元素按顺序依次入栈
        while (head != null){

            stack.push(head.val);

            head = head.next;

        }  

        //依次出栈，并按顺序放入数组中

        int size = stack.size();

        int[] array = new int[size];

        for (int i = 0;i < size;i++){

            array[i] = stack.pop();

        }

        return array;

    }

2.有效的括号

题目链接：20. 有效的括号 - 力扣（LeetCode）

示例：( { [ ] ) }

思路(利用栈的结构)

(1).首先，建立一个参数i去遍历所有的括号

(2).判断遇到了左括号还是右括号

a.如果遇到左括号，则入栈。

b.如果遇到右括号，则查看栈是否为空，如果为空，说明没有左括号与之匹配，如果不为空，则弹出栈顶元素，并与之匹配

情况一：匹配成功，则继续遍历

情况二：匹配失败，则返回false ，程序结束

(3).遍历完全部括号后，检查栈是否为空

情况一：如果不为空，说明仍有左括号没有被右括号匹配，返回false

情况二：如果栈为空，说明括号已经全部匹配成功，返回true

动态图模拟

代码

class Solution {
    public boolean isValid(String s) {
        //申请一个栈
        Stack<Character> stack = new Stack<>();

        //遍历所有括号
            for (int i = 0;i < s.length();i++){
                char ch = s.charAt(i);
                //如果为左括号
                if (ch == '(' || ch == '{' || ch == '['){

                    //入栈
                    stack.push(ch);
                }else{//如果为右括号

                    //判断栈是否为空
                    if (stack.empty()){
                        return false;
                    }else{
                        //出栈，并与之匹配
                        char ch1 = stack.pop();
                        if ((ch1 == '(' && ch == ')') || 
                            (ch1 == '{' && ch == '}') ||
                            (ch1 == '[' && ch == ']')){
                                //如果匹配成功，啥也不干，程序继续
                        }else{
                            //如果匹配失败，则返回false，退出程序
                            return false;
                        }
                    }
                }
            }

            //遍历完所有括号之后，检查栈是否为空
            if (stack.empty()){
                //如果为空，说明所有括号都匹配成功了
                return true;
            }else{
                //如果不为空，说明仍然有左括号未被右括号匹配
                return false;
            }
    }
}

3.逆波兰表达式

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

要想了解本题目，首先得知道前缀，中缀和后缀表达式，下面我们来看一个例子

示例1：1 + 2 * 3

以上示例就是中缀表达式，后缀表达式就是将运算符写在操作数之间，其实就是咱们平时计算的式子

示例2：1 2 3 * +

以上示例就是后缀表达式，后缀表达式就是将运算符写在操作数之后，中缀转为后缀，可以在每个计算式后面加上括号，并按从里到外的顺序把运算符转移到括号外边，如图：

逆波兰表达式，就是后缀表达式，将运算符写在操作数后面，就可以让计算机利用栈去实现运算，并且可以按照+、 -、 *、 /的优先级运算

具体的过程：

思路

(1).遍历字符

(2).遇到数字，则入栈

(3).遇到运算符，则取出栈顶的两个元素，首先取出的元素作为2号位数字，其次的元素作为1号位数字，算出结果后，将结果压入栈中

(4)当遍历完所有字符之后，栈中留下的唯一一个元素即为运算的结果

代码

class Solution {
    public int evalRPN(String[] tokens) {
        //申请一个整形栈
        Stack<Integer> stack = new Stack<>();
        //遍历字符串数组
        for (String str:tokens){
            if (str.equals("+") || str.equals("-") || 
                str.equals("*") || str.equals("/")){
                //如果是符号，则弹出栈顶的两个元素，第一个弹出的元素作为二号位数字，第二个弹出的元素作为一号位元素
                int n2 = stack.pop();
                int n1 = stack.pop();
                switch(str){
                    case "+":
                        stack.push(n1 + n2);
                        break;
                    case "-":
                        stack.push(n1 - n2);
                        break;
                    case "*":
                        stack.push(n1 * n2);
                        break;
                    case "/":
                        stack.push(n1 / n2);
                        break;
                }
            }else{
                //如果是数字，则直接入栈
                stack.push(Integer.valueOf(str));
            }
        }
        return stack.peek();
    }
}

这样利用栈的特性去运算，能够解决加减乘除的优先级问题

本文章到此结束，之后我还会多更新一些面试题给大家练习！

创作不易，希望大家能多多的点赞，多多的支持！