数据结构-栈

栈的基本原理

定义

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

  • 栈的英文为(stack)
  • 栈是一个先入后出的(FILO-First In Last Out)的有序列表
  • 栈(stack)是限制线性表中元素插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端,为变化的的一端,称为 栈顶(top),另外一端为固定的一端,称为 栈底(Bottom)
    • 栈顶(Top):线性表允许进行插入和删除的一端。
    • 栈底(Bottom):固定的,不允许进行插入和删除的另一端。
  • 根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除。
  • 空栈:不含任何元素。

栈1.webp

如上图:a1为栈底元素,an为栈顶元素。由于栈只能在栈顶进行插入和删除操作,故进栈次序依次为a1,a2,… ,an 而出栈次序为an,…,a2,a1。栈的明显的操作特征为后进先出(Last In First Out,LIFO),故又称 后进先出的线性表。

栈的基本操作

  1. InitStack(&S):初始化空栈S
  2. StackEmpty(S):判断一个栈是否为空
  3. Push(&S,x):进栈,若栈未满,则将x加入使之成为新栈顶
  4. Pop(&S,&x):出栈,若栈非空,则将栈顶元素,并用x返回
  5. GetTop(S,&x):读栈顶元素,若栈顶元素非空,则用x返回栈顶元素
  6. DestroyStack(&S):销毁栈,并释放栈S占用的存储空间

栈的顺序存储结构

顺序栈的实现

采用顺序存储的栈称为顺序栈,它是利用一组地址连续的存储单元存放自栈底到栈顶的数据元素,同时附设一个指针(top)指示当前栈顶的位置。

栈的顺序存储类型可以用以下表示:

#define MAXSIZE 100         //栈中元素的最大个数
typedef struct {
    ElemType data[MAXSIZE]; //存放栈中元素
    int top;                //栈顶指针
} SqStack;
  • 栈顶指针:S.top,初始时设置S.top = -1;栈顶元素:S.data[S.top];
  • 进栈操作:栈不满时,栈指针加1,再送值到栈顶元素
  • 出栈操作:栈非空时,先去栈顶元素值,再将栈顶指针减1
  • 栈空条件:S.top == -1
  • 栈满条件:S.top == MAXSIZE - 1
  • 栈长:S.top + 1

顺序栈的基本运算

栈2.webp

初始化

void InitStack(SqStack& S){
    S.top = -1;             //初始化栈顶指针
}

判栈空

bool StackEmpty(SqStack& S){
    if( S.top == -1){
        return true;
    }
    return false;
}

进栈

bool Push(SqStack& S, ElemType x){
    if( S.top == MAXSIZE - 1 ){ //栈满,报错
        return false;        
    }
    S.top ++ ;                  //栈顶指针加1
    S.data[S.top] = x;          //入栈
    return true;
}

出栈

bool Pop(SqStack& S, ElemType& x){
    if( S.top == -1 ){          //栈空,报错
        return false;
    }
    x = S.data[S.top];
    S.top --;
    return true;
}

读栈顶元素

bool GetTop(SqStack& S,ElemType& x){
    if( S.top == -1 ){          //栈空,报错
        return false;
    }
    x = S.data[S.top];
    return true;
}

注意:若栈顶指针初始化为S.top = 0,即栈顶指针指向栈顶元素的下一个位置,则入栈操作变为S.data[S.top++],出栈操作为x = S.data[–S.top]。因为栈顶指针若初始化为 0 时,则栈顶指针始终指向顺序栈将要入栈的位置,也就是栈顶指针的下标就是入栈元素的下标。

共享栈

利用栈底位置相对不变的特性,可以让两个顺序栈共享一个一维数据空间,将两个栈的栈底分别设置在共享空间的两端,两个栈顶向共享空间的中间延伸。

栈3.webp

两个栈的栈顶指针都指向栈顶元素,top1 = -1 时,stack1 为空,top2 = MAXSIZE - 1 时,stack2 为空;仅当两个栈顶指针相邻(top1 - top2 == 1)时,判断栈满。当stack1进栈时top1先加1再赋值,stack2进栈时top2先减1再赋值;出栈正好相反。

共享栈是为了更有效地利用存储空间,两个栈的空间正好互相调节,只有在整个存储空间被占满时才发生上溢。存取数据的时间复杂度均为O(1),所以对存取效率没有什么影响。

栈的链式存储结构

采用链式存储的栈称为链栈,链栈的优点是便于多个栈共享存储空间和提高其效率,且不存在栈满上溢的情况。通常采用单链表实现,并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头结点,top指向栈顶元素,

栈4.webp

链栈的存储类型可描述为:

typedef struct LinkNode{
    ElemType data;
    struct LinkNode* next;
}LinkNode, *LinkStack;

栈在Java中的应用

应用场景

  1. 子程序的调用:在跳往子程序前,会先将下一个指令的地址存到堆栈中,直到子程序执行完后再将地址取出,以回到原来的程序中。
  2. 处理递归调用:和子程序的调用类似,只是除了储存下一个指令的地址外,也将参数,区域变量等数据存入堆栈中。
  3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)
  4. 二叉树的遍历
  5. 图形的深度优化(depth—first)搜索法

示例

栈实现综合计算器

要求
用栈实现计算器

思路分析

栈5.webp

  1. 通过一个index值(索引),来遍历我们的表达式
  2. 如果我们发现是一个数字,就直接入数栈
  3. 如果发现扫描到是一个符号,就分如下情况
    1. 如果发现当前符号栈为空,就直接入栈
    2. 如果符号栈有操作符,就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,再从符号栈中pop一个符号,进行运算,将得到结果,入数栈,然后将当前操作符入符号栈,如果当前的操作符的优先级大于等于栈中的操作符,就直接入符号栈。
  4. 当表达式扫描完毕之后,就顺序的从数栈和符号栈中pop出相应的数和符号,并且运算
  5. 最后在数栈只有一个数字,就是表达式的结果。

代码实现

public class Calculator {
    public static void main(String[] args){
        //根据前面思路,完成表达式的运算
        String expression = "25*2*10+2*8+4";
        //创建两个栈,数栈,符号栈
        ArraySatck2 numStack = new ArraySatck2(10);
        ArraySatck2 operStack = new ArraySatck2(10);
        //定义需要的相关变量
        int index = 0;//用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';//将每次扫描得到的char保存到ch中
        String keepNum = "";//用于拼接多位数
        //开始循环扫描expression
        while (true){
            //依次得到expression的每一个字符
            ch = expression.substring(index,index +1 ).charAt(0);
            //判断ch是什么,然后做相应的处理
            if (operStack.isOper((ch))){//如果是运算符
                //判断当前符号栈是否为空
                if (!operStack.isEmpty()){
                    //不为空的处理
                    //思路分析第三条
                    //如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,再从符号栈中pop一个符号,进行运算,将得到结果,入数栈,然后将当前操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        //把运算结果入数栈
                        numStack.push(res);
                        //把当前操作符入入符号栈
                        operStack.push(ch);
                    }else {
                        //如果当前的操作符的优先级大于等于栈中的操作符,就直接入符号栈。
                        operStack.push(ch);
                    }
                }else {
                    //如果为空直接入栈
                    operStack.push(ch);//例如1+1,前面没有符号。则直接把 + 放入
                }
            }else {//如果是数。则直接入数栈
                //numStack.push(ch); 这样写是不对的:比如"1+3",扫描到的是这个"1",而不是 1
                //numStack.push(ch - 48);这样也不对
                //分析思路
                //1.当处理多位数时,不能发现一个一个数就历即入栈,因为他可能多位数
                //2.在处理数,需要向expression的表达式后面index后再看一位,如果是数就继续扫描,如果是符号就入栈
                //3.因此我们需要定义一个变量 字符串,用于拼接
                //处理多位数
                keepNum += ch;
                //如果ch已经是最后一位了,则直接入栈
                if (index == expression.length() - 1){
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    //判断下一位字符是不是数字,如果是数字,则继续扫描,如果是运算符则入栈
                    //注意是看后一位,不是index++
                    if (operStack.isOper(expression.substring(index + 1,index + 2).charAt(0))){
                        //如果后一位是运算符则入栈,keepNum为字符串,需要转换为int
                        numStack.push(Integer.parseInt(keepNum));
                        //重要!!!!!!,keepNum清空
                        keepNum = "";
                    }
                }
            }
            //让index + 1;并且判断是否到达expression最后
            index ++;
            if (index >= expression.length()){
                break;//扫描结束
            }
        }
        //当表达式扫描完毕之后,就顺序的从数栈和符号栈中pop出相应的数和符号,并且运算
        while (true){
            //如果符号栈为空,则计算结束,得到最后结果,数栈中最后的数值就是结果
            if (operStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);
            numStack.push(res);//入栈
        }
        //将数栈的最后结果输出
        System.out.println("表达式" + expression + "的结果为:" + numStack.pop());
    }
}
//先创建一个栈,直接使用前面创建好的
//定义一个类ArraySatck2来表示栈,需要扩展功能
class ArraySatck2{
    private int maxSize;//栈的大小
    private int[] stack;//数组,数组模拟栈,数据就放在该数组
    private int top = -1;//top表示栈顶,初始化为-1
    //构造器
    public ArraySatck2(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    //增加一个方法,可以返回栈顶的值,并不会被取出
    public int peek(){
        return stack[top];
    }
    //栈满
    public boolean isFull(){
        return top == maxSize - 1;
    }
    //栈空
    public boolean isEmpty(){
        return top == -1;
    }
    //入栈push
    public void push(int value){
        //先判断栈是否满
        if (isFull()){
            System.out.println("栈满~~");
            return;
        }
        top++;
        stack[top] = value;
    }
    //出栈pop,将栈顶的数据返回
    public int pop(){
        //先判断栈是否空
        if (isEmpty()){
            //抛出异常
            throw  new RuntimeException("栈空~~没有数据~~");
        }
        int value = stack[top];
        top --;
        return value;
    }
    //显示栈,遍历栈,遍历时需要从栈顶开始显示数据
    public void list(){
        if (isEmpty()){
            System.out.println("栈空没有数据~~");
        }
        for (int i = top ; i >= 0;i --){
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }
    //返回运算符的优先级,优先级是程序员来确定的,优先级使用数字表示
    //数字越大,则优先级越高。
    public int priority(int oper){
        if (oper == '*' || oper == '/'){
            return 1;
        }else if (oper == '+' || oper == '-'){
            return 0;
        }else {
            return -1;//假定目前的表达式只有+,-,*,/四种运算符
        }
    }
    //判断是不是一个运算符
    public boolean isOper(char val){
        return val == '+' || val == '-' || val == '*' || val == '/';
    }
    //
    //计算方法
    public int cal(int num1,int num2,int oper){
        int res = 0;//用于存放计算的结果
        switch (oper){
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}