数据结构-栈

最新推荐文章于 2024-05-07 20:19:25 发布

Ayin的学习笔记

最新推荐文章于 2024-05-07 20:19:25 发布

阅读量924

点赞数 1

文章标签：数据结构栈堆栈

本文链接：https://blog.csdn.net/AyinMars/article/details/120386631

版权

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。
栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为先进后出表。
栈可以用来在函数调用的时候存储断点，做递归时要用到栈！

注意：栈的所有操作都在栈顶进行！ 在这里插入图片描述

栈的实现方式一共有两种，一是数组实现顺序栈，一种是链表实现链式栈，这两者要通过具体的情况来进行选择使用，如果线性表主要是进行查询操作，则优先选择顺序存储的线性表~

栈的顺序实现

在这之前，我们需要定义一个数组element来存储元素，然后再定义一个栈顶指针top，当栈为空时，栈顶指针和栈底指针都指向数组下标为0的位置！并且，我们定义一个变量，设置类在调用空参构造器时，所创建的数组的默认大小。

根据上述说法，可以得到以下结论：栈顶指针top当前指向的下标等于数组元素的个数！数组判空只需要判断栈顶指针是否小于或等于0即可！

// 返回当前数组元素个数
public int  getSize() {
    return top;
}
public boolean isEmpty() {
    return top <= 0;
}

入栈和出栈

入栈时，首先将需要入栈的元素添加至栈顶指针top当前指向的位置，然后栈顶指针后移，即top++
出栈时，因为此时的栈顶指针指向数组中最后一个元素的后一个下标位置，所以我们需要将栈顶指针下移，即top–，然后再返回此时栈顶指针指向的数组元素。
如果想要展示栈顶元素而不打算删除该元素，可以通过element[top-1]该条件来返回栈顶元素。
在这之前，我们定义了数组的默认大小，但是在不断入栈的情况下，数组空间很快就会不足，于是我们在入栈操作之前加入一个判断，如果此时数组已满，则执行一个数组扩容方法，将原本的数组容量扩容至两倍~

// 入栈
public void push(Object e) {
    // 数组扩容
    if (top > element.length) {
        Object[] newElement = new Object[element.length * 2];
        for (int i = 0; i < element.length; i++) {
            newElement[i] = element[i];
        }
        element = newElement;
    }
    element[top] = e;
    top++;
}
// 出栈
public Object pop() {
    if (top <= 0) {
        return "栈已空！";
    }
    top--;
    return element[top];
}
// 返回栈顶元素(不删除元素)
public Object peek() {
    if (top <= 0) {
        return "栈已空！";
    }
    return element[top - 1];
}
// 栈的遍历
public void display() {
    // 因为栈顶指针始终指向数组最后一个元素的后一个位置
    for (int i = top - 1; i >= 0 ; i--) {
        System.out.println(element[i] + " ");
    }
}

栈的链式实现

使用链表作为栈的存储结构，有时候也成为链栈。

因为栈只允许在线性表的一段进行操作，所以链栈可以选择在链表的头部进行操作，不管是入栈还是出栈都在链表的首结点进行！

链式结构需要定义一个结点类，有存放数据data和下一个结点的引用next这两个属性！

入栈和出栈

定义一个结点作为栈顶指针，命名为top，然后再定义一个size，记录栈元素的个数！
入栈时，创建一个新的结点pNode来存放新添加的数据e，并将pNode.next指向top，然后再将top指针上移，也就是将top=pNode，最后size+1
出栈时，只要将栈顶指针top后移即可，即top=top.next，但是需要返回被出栈的元素，于是在指针后移之前，创建一个变量来存储元素，即Object=top.data，最后再将data返回即可！
遍历栈元素，创建一个辅助结点pNode作为指针指向top，当top不等于null时，输出栈元素，然后再将辅助结点后移！

 // 出栈
    public Object pop() {
        if (isEmpty()) {
            return "栈为空！";
        }
        Object oldData = top.data;
        top = top.next;
        size--;
        return oldData;
    }
    // 返回栈顶元素
    public Object peek() {
        if (isEmpty()) {
            return "栈为空！";
        }
        return top.data;
    }
	// 遍历栈元素
    public void display() {
        if (isEmpty()) {
            return;
        }
        Node pNode = top;
        while(pNode != null) {
            System.out.print(pNode.data + " ");
            pNode = pNode.next;
        }
        System.out.println();
    }
}

扩展：利用栈实现进制转换

进制转换是人们利用符号来计数的方法。进制转换由一组数码符号和两个基本因素“基数”与“位权”构成。基数是指，进位计数制中所采用的数码（数制中用来表示“量”的符号）的个数。位权是指，进位制中每一固定位置对应的单位值。

10进制转2/8/16进制：

对于整数部分，用被除数反复除以2，除第一次外，每次除以2均取前一次商的整数部分作被除数并依次记下每次的余数。另外，所得到的商的最后一位余数是所求二进制数的最高位。

对于小数部分，采用连续乘以基数2，并依次取出的整数部分，直至结果的小数部分为0为止。故该法称“乘基取整法”。

10进制数转换成8进制的方法，和转换为2进制的方法类似，唯一变化：除数由2变成8。

10进制数转换成16进制的方法，和转换为2进制的方法类似，唯一变化：除数由2变成16。

利用栈后入先出的特性，我们可以将原10进制的数除去进制数之后得到的余数压入栈中，循环此操作，最后用出栈的方式将栈元素输出，这样就得到了反向写出的2/8/16进制数。

以下代码为进制转换的具体实现：

public class BinaryConversionByStack {
    public static void main(String[] args) {
        BinaryConversionByStack stack = new BinaryConversionByStack();
        System.out.println(stack.BinaryConversion(154, 2));

    }
    /**
     * 进制转换
     * @param number 十进制数
     * @param decimal 进制
     */
    public String BinaryConversion(int number, int decimal) {
        LinkedStack stack = new LinkedStack();
        int remainder; // 余数
        while(number != 0) {
            remainder = number % decimal;
            stack.push(remainder);
            number = number / decimal;
        }
        // 使用StringBuilder类来输出栈元素
        StringBuilder sb = new StringBuilder(); 
        while (true) {
            if (stack.isEmpty()) {
                break;
            }
            sb.append(stack.pop());
        }
        return sb.toString();
    }
}

扩展：检测表达式括弧是否匹配分析

假设表达式中，包含着三种括弧，分别为小括弧()，中括弧[]，大括弧{}，这三种括弧可以任意嵌套，例如：(3*5)+[5/4]-{15%2}

对于任意一个左括弧都需要一个右括弧来进行匹配，且，最早出现的左括弧应该和最晚出现的右括弧进行匹配！

于是我们可以通过这样一个思路：将左括弧依次压入栈中，直到第一个右括弧出现，先判断左右括弧是否匹配，若不匹配，说明这个表达式并不合法；如果匹配，再将左括弧出栈，这样就可以将左右括弧进行匹配！

如果右括弧的已出现但是栈内已空，则一样说明表达式不合法；读完整个表达式，发现栈没有空，表示还有左括弧并没有进行匹配，也说明该表达式不合法！

public class BracketMatchByStack {
    public static void main(String[] args) {
        BracketMatchByStack stack = new BracketMatchByStack();
        System.out.println(stack.bracketMatch("({[]})"));
        System.out.println(stack.bracketMatch("{[()]"));
        System.out.println(stack.bracketMatch("[()]}"));
    }
    public boolean bracketMatch(String expression) {
        LinkedStack stack = new LinkedStack();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i); // 将字符串中的每一个字符取出
            switch (c) {
                case '(':
                case '[':
                case '{':
                    stack.push(c); // 如果字符(、{、[则将其入栈
                    break;
                case ')':
                    // 如果字符为)、}、]，栈顶元素为对应的右括弧，且栈不为空，则将其出栈
                    if (!stack.isEmpty() && stack.peek().equals('(')) {
                        stack.pop();
                        break;
                    } else {
                        return false;
                    }
                case ']':
                    if (!stack.isEmpty() && stack.peek().equals('[')) {
                        stack.pop();
                        break;
                    } else {
                        return false;
                    }
                case '}':
                    if (!stack.isEmpty() && stack.peek().equals('{')) {
                        stack.pop();
                        break;
                    } else {
                        return false;
                    }
                }
            }
        if (stack.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}

扩展：表达式求值分析

在四则运算中，存在着一些人尽皆知的运算规则：先乘除后加减，先括弧内再括弧外，从左到右进行运算!

例如表达式：4+2+(6-10+2×3)×4

在上述表达式中，先进行运算的是4+2=6，然后再运算括号内的2×3=6，在依次运算6-10+6=2并去掉括号，最后运算2×4=8，6+8=14！

那如何使用代码来表达这种规则呢？

思路如下：

定义两个栈，一个存储运算符operator，一个存储操作数operand
读取表达式

（1）如果是操作数就存储到operand操作数栈

（2）如果是运算符

1）当前运算符栈为空，则直接入栈

2）把运算符栈中的栈顶运算符和当前运算符进行优先级比较，当前运算符优先级高，则入栈；如果栈顶运算符优先级高，弹出栈顶运算符，从操作数栈中弹出两个操作数进行运算，并将运算结果存储到操作数栈中，然后继续判断当前运算符的优先级
遍历完整个表达式，两个栈都不为空，则依次弹出运算符operator栈中的运算符和操作数栈中的两个操作数进行运算，再把结果存储到操作数栈中
如果运算符栈不为空，或者操作数栈中的数有余，则表达式错误

具体实现我们可以分为以下几个步骤：

取出操作数（需要注意的是，我们使用的charAt方法只能一次性取出一个字符，不能将其直接压栈，如果操作数为两位数，例如68，则入栈的数据将会是6而不是68，于是我们需要一个循环，直到下一个运算符之前，取出的操作数全部合并后入栈）
判断运算符（栈为空时，直接将当前运算符入栈，如果栈不为空，使用compareOperator方法判断运算符的优先级，且只有是括弧的情况下，才会出现优先级相等的情况！）

public class CalculateExpressionByStack {
    public static void main(String[] args) {
        String str = "4+2*4+(6*3+2)";
        double result = caculate(str);
        System.out.println(result);
    }
    private static double caculate(String expression) {
        LinkedStack operatorStack = new LinkedStack(); // 运算符栈
        LinkedStack operandStack = new LinkedStack(); // 操作数栈
        for (int i = 0; i < expression.length(); i++) {
            char cc = expression.charAt(i);
            if (Character.isDigit(cc)) { // 如果cc是数字
                // 取出操作数（需要考虑操作数为两位数及以上的情况）
                StringBuilder sb = new StringBuilder();
                while(Character.isDigit(cc)){
                    sb.append(cc);
                    i++; // 取出一个字符后，i+1
                    if (i >= expression.length()) { // 当i大于表达式长度时，则表达式以结束
                        break;
                    }
                    cc = expression.charAt(i); // 取下一个字符
                }
                // 操作数入栈
                operandStack.push(sb.toString());
                // 修正i变量的值
                /*
                   因为在for循环中已经有了i自增
                   当操作数入栈后，此时的i指向了运算符
                   然后又for循环进行自增，于是i又指向了操作数，跳过了运算符
                */
                i--;
            } else { // 如果cc是运算符
                // 运算符栈为空
                if (operatorStack.isEmpty()) {
                    operatorStack.push(cc);
                    continue;
                }
                // 运算符栈不为空
                while( ! operatorStack.isEmpty()) {
                    char op1 = (char) operatorStack.peek(); // 取栈顶元素
                    // 判断取出的运算符与当前运算符的优先级
                    if (compareOperator(op1, cc) < 0) {
                        operatorStack.push(cc);
                        break;
                    } else if (compareOperator(op1, cc) == 0) {
                        // cc的优先级等于op1，只有一种情况，也就是左括弧遇上了右括弧
                        operatorStack.pop();
                        break;
                    } else {
                        // cc的优先级低于op1
                        // 取出两个操作数
                        double num1 = Double.parseDouble(operandStack.pop().toString());
                        double num2 = Double.parseDouble(operandStack.pop().toString());
                        // 取栈顶元素
                        char  operator = (char) operatorStack.pop();
                        double result = compute(operator, num1, num2);
                        operandStack.push(result);
                        if (operatorStack.isEmpty()) {
                            operatorStack.push(cc);
                            break;
                        }
                    }
                }
            }
        }
        // 当表达式遍历完之后，运算符栈不为空，则需要继续计算
        while( ! operatorStack.isEmpty()) {
            char  operator = (char) operatorStack.pop();
            double num1 = Double.parseDouble(operandStack.pop().toString());
            double num2 = Double.parseDouble(operandStack.pop().toString());
            double result = compute(operator, num1, num2);
            operandStack.push(result);
        }
        // 运算符遍历完成后，操作数栈多于一个数，则表达式有误
        if (operandStack.getSize() > 1) {
            try {
                throw new Exception("表达式错误");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return Double.parseDouble(operandStack.pop().toString());
    }
    // 计算num1 peel num2的值
    private static double compute(char peek, double num1, double num2) {
        switch (peek) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
            case '/':
                return num1 / num2;
        }
        return 0;
    }
    // 判断优先级，如果op1优先级高，返回正数，反之返回负数，相等则返回0
    // op1为栈顶运算符，op2为当前运算符
    private static int compareOperator(char op1, char op2) {
        if (op1 == '+' || op1 == '-') {
            if (op2 == '*' || op2 == '/' || op2 == '(') {
                return -1;
            }
        }
        if (op1 == '*' || op1 == '/') {
            if (op2 == '(') {
                return -1;
            }
        }
        if (op1 == '(') {
            if (op2 == ')') {
                return 0;
            } else {
                return -1;
            }
        }
        return 1;
    }
}

Ayin的学习笔记

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
数据结构-栈

栈栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数
复制链接

扫一扫