数据结构：栈

已于 2022-03-17 23:00:50 修改
阅读量1.1k 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 栈
于 2022-03-16 19:35:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42641022/article/details/123528071
版权

1、栈的介绍

  • 栈的英文为 stack)
  • 栈是一个先入后出(HILO- First In Last Out)的有序列表。
  • 栈( stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底( Bottom)。
  • 根据栈的定义可知,最先放入中元素在栽底,最后放入的元素在栽顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除
  • 图解方式说明出栽(pop)和入(push)的概念
    在这里插入图片描述

2、 栈的应用场景

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

3、栈的快速入门

  • 用数组模拟栈的使用,由于栈是一种有序列表,当然可以使用数组的结构来储存栈的数据内容,下面就用数组模拟栈的出栈,入栈等操作。
  • 实现思路分析,并画出示意图

在这里插入图片描述
实现代码：

package stack;

import java.util.Scanner;

/**
 * Create with IntelliJ IDAE
 *
 * @Author: JINLEI
 * @Description: 用数组模拟栈
 * @Date: 2022/3/16
 * @Time: 15:47
 **/
public class ArrayStackDemo {
    public static void main(String[] args) {

        //测试
        ArrayStack stack = new ArrayStack(4);
        String key = " ";
        boolean loop = true;//控制是否退出菜单
        Scanner scanner = new Scanner(System.in);
        while (loop){
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示入栈");
            System.out.println("pop: 表示出栈");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key){
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try{
                        int res = stack.pop();
                        System.out.printf("出栈的数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}
//定义ArrayStack表示栈
class ArrayStack{
    private int maxSize;//栈的大小
    private int[] stack;//数组，数组模拟栈，数据放在该数组中
    private int top = -1;//top表示栈顶

    //构造器
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //栈满
    public boolean isFull(){
        return top == maxSize - 1;
    }
    //栈空
    public boolean isEmpty(){
        return top == -1;
    }
    //入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }
    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top--;
        return value;
    }
    //显示栈的情况(遍历栈)
    public void list(){
        if (isEmpty()){
            System.out.println("栈空没有数据");
            return;
        }
        for (int i = top; i >= 0 ; i--) {
            System.out.printf("stack[%d] = %d\n",i,stack[i]);
        }
    }
}

4、栈实现综合计算器（中缀表达式）

思路分析图解：
在这里插入图片描述
实现代码：

package stack;

import java.util.Stack;

/**
 * Create with IntelliJ IDAE
 *
 * @Author: JINLEI
 * @Description: 用栈实现计算器
 * @Date: 2022/3/16
 * @Time: 16:27
 **/
public class Calculator {
    public static void main(String[] args) {

        //根据思路完成表达式的运算
        String exp = "7+2*6-4";
        //创建两个栈 数栈和符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0;//用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';//将每次扫描得到的char保存在ch
        String keepNum = "";
        //开始while循环扫描exp
        while (true){
            //依次得到exp的每一个字符
            ch = exp.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);
                }
            }else {//如果是数
                //numStack.push(ch - 48);//'1'=>1
                //处理多位数时，需要向exp表达式的index后再看一位，如果是数字就进行扫描，如果是符号才入栈
                //需要定义一个变量字符串用于拼接
                keepNum += ch;
                //如果ch是最后一位
                if (index == exp.length()-1){
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    //判断下一个字符是不是数字，如果是就继续扫描，否则入栈
                    if (operStack.isOper(exp.substring(index+1,index+2).charAt(0))) {
                        //如果后一位是运算符，则入栈keepNum = “ 1”或者“ 123”
                        numStack.push(Integer.parseInt(keepNum));
                        //keepNum清空
                        keepNum = "";
                    }
                }
            }
            //index+1并判断是否扫描到exp最后
            index++;
            if (index >= exp.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);//入栈
        }
        //将数栈最后的数pop就是结果
        System.out.printf("表达式%s = %d",exp,numStack.pop());
    }
}

//创建栈
class ArrayStack2{
    private int maxSize;//栈的大小
    private int[] stack;//数组，数组模拟栈，数据放在该数组中
    private int top = -1;//top表示栈顶

    //构造器
    public ArrayStack2(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //返回当前栈顶的值，不是真正的pop
    public int peek(){
        return stack[top];
    }
    //栈满
    public boolean isFull(){
        return top == maxSize - 1;
    }
    //栈空
    public boolean isEmpty(){
        return top == -1;
    }
    //入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }
    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top--;
        return value;
    }
    //显示栈的情况(遍历栈)
    public void list(){
        if (isEmpty()){
            System.out.println("栈空没有数据");
            return;
        }
        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;//res用于存放计算结果
        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;
    }
}

5、逆波兰计算器（后缀表达式）

完成一个逆波兰计算器，要求完成如下任务

  • 输入一个逆波兰表达式(后缀表达式)，使用栈( Stack），计算其结果
  • 支持小括号和多位数整数，因为这里我们主要讲的是数据结构,因此计算器进行简化,只支持对整数的计算。
  • 思路分析
    在这里插入图片描述
    代码实现：
package stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * 逆波兰表达式（后缀表达式）
 * @author jinlei
 * @time 2022年3月17日下午6:56:15
 */
public class PolandNotation {

	public static void main(String[] args) {
		
		//定义一个逆波兰表达式
		//（30+4）*5-6  =》30 4 + 5 * 6 -
		//
		//为了方便逆波兰表达式的数字和符号用空格隔开
		String suffixExpression = "30 4 + 5 * 6 -";//164
		
		//1、先将"3 4 + 5 * 6 -"放到ArrayList中
		//2、将ArrayList传递一个方法，配合栈完成
		List<String> list = getListString(suffixExpression);
		System.out.println("list = " + list);
		
		int res = calculate(list);
		System.out.println("计算的结果是 = " + res);

	}
	
	//将一个逆波兰表达式依次将数字和运算符放入ArrayList
	public static List<String> getListString(String suffixExpression){
		//将suffixExpression分割
		String[] split = suffixExpression.split(" ");//返回String数组
		List<String> list = new ArrayList<>();
		for (String ele : split) {
			list.add(ele);
		}
		return list;
	}
	
	//完成计算
	public static int calculate(List<String> ls) {
		
		//创建一个栈
		Stack<String> stack = new Stack<String>();
		//遍历ls
		for (String item : ls) {
			//使用正则表达式取出数
			if(item.matches("\\d+")) {//匹配的是多位数
				//入栈
				stack.push(item);
			}else {
				//pop出两个数并运算再入栈
				int num2 = Integer.parseInt(stack.pop());
				int num1 = Integer.parseInt(stack.pop());
				int res = 0;
				if(item.equals("+")) {
					res = num1 + num2;
				}else if(item.equals("-")) {
					res = num1 - num2;
				}else if(item.equals("*")){
					res = num1 * num2;
				}else if (item.equals("/")) {
					res = num1 / num2;
				}else {
					throw new RuntimeException("运算符有误");
				}
				//把res入栈
				stack.push("" +res);
			}
		}
		//最后留在栈中的就是结果
		return Integer.parseInt(stack.pop());
		
	}

}

6、中缀表达式转后缀表达式

具体步骤如下：
在这里插入图片描述
实现代码：

package stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * 中缀表达式转后缀表达式
 * @author jinlei
 * @time 2022年3月17日下午9:40:11
 */
public class InfixToSuffix {

	public static void main(String[] args) {
		
		//说明
		//1、因为直接对str进行操作不方便，因此创建中缀对应的List
		//2、即“1+((2+3)*4)-5”  => ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
		
		String expression = "1+((2+3)*4)-5";
		List<String> iel = toInfixExpression(expression);
		System.out.println("中缀表达式对应的list = "+ iel);
		
		List<String> psel = parseSuffixExpressionList(iel);
		System.out.println("后缀表达式对应的list = "+psel);
		
		
	}
	
	//方法：将得到的中缀表达式的list =》后缀表达式的list
	public static List<String> parseSuffixExpressionList(List<String> ls){
		
		//创建两个栈
		Stack<String> s1 = new Stack<String>();//符号栈
		//因为s2在整个过程中没有pop操作，最后需要逆序，所以不用栈换成list
		//Stack<String> s2 = new Stack<String>();//存放中间结果的栈
		List<String> s2 = new ArrayList<String>();//存放中间结果的栈
		
		//遍历ls
		for (String item : ls) {
			//如果是一个数加入s2
			if(item.matches("\\d+")) {
				s2.add(item);
			}else if (item.equals("(")) {
				s1.push(item);
			}else if (item.equals(")")) {
				//如果是右括号依次弹出s1栈顶的运算符并压入s2，
				//直到遇到左括号为止，此时将一对括号丢弃
				while (!s1.peek().equals("(")) {
					s2.add(s1.pop());
				}
				s1.pop();//将(弹出s1栈，清除小括号
			}else {
				//当item的优先级小于等于s1栈顶元素，将s1栈顶的运算符弹出并压入s2
				while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
					s2.add(s1.pop());
				}
				//还需要将item压入栈
				s1.push(item);
			}
		}
		//将s1中剩余的运算符依次加入s2
		while (s1.size() != 0) {
			s2.add(s1.pop());
		}
		return s2;//注意是存放再list因此按顺序输出就是对应的结果
	}
	
	//方法：将中缀表达式转成对应的list
	public static List<String> toInfixExpression(String s){
		List<String> ls = new ArrayList<>();
		int i = 0;//指针用于遍历中缀表达式
		String str;//多位数的拼接
		char c;//遍历到字符放入c中
		while (i < s.length()) {
			//如果c是一个非数字就需要加入到ls中
			if((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
				ls.add("" + c);
				i++;
			}else {//如果是一个数，需要考虑多位数
				str = "";//将str置空
				while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
					//拼接
					str += c;
					i++;
				}
				ls.add(str);
			}
		}
		return ls;
	}

}

//类：返回一个运算符的优先级
class Operation{
	private static int ADD = 1;
	private static int SUB = 1;
	private static int MUL = 2;
	private static int DIV = 2;
	
	//写一个方法返回对应的优先级数字
	public static int getValue(String opertion) {
		int result = 0;
		switch (opertion) {
		case "+":
			result = ADD;
			break;
		case "-":
			result = SUB;
			break;
		case "*":
			result = MUL;
			break;
		case "/":
			result = DIV;
			break;
		default:
			System.out.println("不存在该运算符");
			break;
		}
		return result;
	}
}
lewjin
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：栈子系统.docx
07-11
数据结构：栈子系统全文共8页，当前为第1页。数据结构：栈子系统全文共8页，当前为第1页。/* 数据结构：栈子系统全文共8页，当前为第1页。 数据结构：栈子系统全文共8页，当前为第1页。 *题目：设计一个字符型的链栈...
数据结构与算法--栈
m0_51303653的博客
10-30 485
栈基本定义基本操作栈的表示和实现顺序栈链式栈顺序表和链表的比较栈的应用四则表达式求值中缀转后缀栈与递归的实现 基本定义 栈是限定仅在表尾进行插入或删除操作的线性表。先进后出 通常，表头端称为栈底，表尾端称为栈顶。 栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 基本操作 InitStack( &S ) //构造空栈 StackEmpty( S ) //判断栈空 Push( &S, e )
栈的应用(四则运算后缀表达式)
weixin_61898526的博客
04-23 1334
后缀(逆波兰)表示法：一种不需要括号的后缀表示法，所有运算符都是在要运算数字的后面，比如后缀表达式9 3 1 - 3 * + 10 2 / + 就是中缀表达式 9 + (3 - 1) × 3 + 10 / 2 后缀表达式可以用栈来实现 规则：创建一个空栈，把后缀表达式依次进栈，要求遇到数字就进栈，遇到符号就将栈顶的两个数字依次出栈，进行运算后，运算结果进栈，直到获得最终结果。 画图举例：9 3 1 - 3 * + 10 2 / + 第一步：9 3 1 依次进栈 第二步：遇...
栈（前缀、中缀、后缀表达式、递归）Stack
Simon郎的博客
01-31 1780
三、栈（Stack） 1、栈的概念 ​ 栈与队列相反，队列是在队头进入，队尾出队的线性表，栈是仅能在栈顶进行插入和删除的线性表(先入先出)。我们通常把允许插入和删除的一端成为栈顶，另一端称为栈底。栈的插入操作为入栈，栈的删除操作为出栈，不含任何数据元素的栈称为空栈。 栈的表示： 用数组模拟栈 用链表模拟栈 2、栈的应用场景 前缀、中缀和后缀表达式 前缀表达式是运算符在前，数字符在后 (...
java 前缀匹配_数据结构 [Java版本] 栈 & 三种表达式(前缀 中缀 后缀)
weixin_39615499的博客
03-07 335
栈的一个实际需求请输入一个表达式计算式:[722-5+1-5+3-3] 点击计算【如下图】需求图请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，讨论的是这个问题。-> 栈栈的介绍栈的英文为(stack)1.栈是一个先入后出(FILO-First I...
数据结构笔记——栈的应用（二）
晓风岚月
05-12 1067
目录 一、中缀表达式转后缀表达式（机算） 二、中缀表达式的计算（用栈实现） 一、中缀表达式转后缀表达式（机算） 初始化一个栈，用于保存暂时还不确定运算顺序的运算符。 从左到右处理各个元素，直到末尾。可能遇到三种情况： ①遇到操作数。直接加入后缀表达式。 ②遇到界限符。遇到“（”直接入栈；遇到“）”则依次弹出栈内运算符并加入后缀表达式，直到弹出“（”为止。 注：“（”不加入后缀表达式。 ③遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到“（”或栈空则停
数据结构：栈的应用《算数表达式求值》
04-03
本人数据结构课设题目：《算术表达式求值》的相应代码
数据结构:栈(包含线性表)
04-15
在这个主题中，我们将深入探讨一种特殊的数据结构——栈（Stack），以及它与线性表的关系。栈是一种后进先出（Last In, First Out，简称LIFO）的数据结构，这意味着最后插入的元素最先被移除。栈在许多算法和程序...
数据结构：栈子系统.doc
09-26
数据结构：栈子系统.doc
数据结构笔记：栈
01-20
原文地址[ 分类目录——数据结构笔记]...由于栈数据结构只允许在一段进行操作，因而按照后进先出（LIFO，Last In First Out）的原理运作。 可以通过线性表（顺序表或链表）实现，通
数据结构与算法-栈
qq_15231055的博客
02-14 187
数据结构与算法-栈栈如何理解栈如何实现一个“栈”?栈在函数调用中的应用栈在表达式求值中的应用栈在括号匹配中的应用引用 栈 如何理解栈 后进者先出，先进者 后出，这就是典型的“栈”结构。 从栈的操作特性上来看，栈是一种“操作受限”的线性表，只允许在一端插入和删除数据。 如何实现一个“栈”? 栈主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据和从栈 顶删除一个数据。 栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，叫作顺序栈，用链表实现的 栈，叫作链式栈。 public class Array
数据结构（二）：栈
m0_51312071的博客
11-23 1341
栈：只能在一端进行元素的插入和删除操作的线性表 特点：first in,last out 一. 1.栈的常规操作： 2.栈溢出的处理 单个栈：开辟更大的空间 多个栈： 分别开辟更大的空间 共享空间，“浮动再分配” 二.链式储存结构 储存方式：同一般的线性单链表储存一样，但要注意栈顶和栈底 好处：动态分配空间，没有栈溢出的问题 ...
【数据结构】详解栈的应用之表达式求值
热门推荐
小k要加油的博客
11-04 1万+
首先明白： 前缀表达式：符号在前，如+ab 中缀表达式：符号在中间，如a*b 后缀表达式：符号在最后，如ab- 举例：求5+7*3*(2+1) 思路： 准备两个栈，将所有的数字放入左栈，所有的符号放入右栈 中缀表达式转后缀表达式的方法: 1.遇到操作数:直接输出(添加到后缀表达式中) 2.栈为空时，遇到运算符，直接入栈 3.遇到左括号:将其入栈 4.遇到右括号:执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括 号，左括号不输出。(删除) 5.遇到其他运算符:加减乘除:弹出所有优先
【数据结构】 栈
愿万事胜意
08-16 669
栈的概念 栈是一种受限制的线性表，是只能在表尾进行插入和删除操作。 在我们日常生活中，一些软件的撤回功能，每次撤回到上一步，还有浏览器的后退键也是和栈的原理大同小异。 允许插入和删除的一端被称为栈顶，另一端被称为栈底，栈遵循后进先出的原则。 栈的插入操作，叫做入栈，栈的删除操作，叫做出栈。 栈的应用--四则运动表达式求值 使用逆波兰表示法： 从左向右开始扫描中缀表达式； 遇到数...
对象栈和运算栈
snowyuuu的博客
08-27 6400
表达式3*2^(4+2*2-6*3)-5求值过程中当扫描到6时,对象栈和运算符栈为(),其中^为乘幂 A.3,2,4,1,1;(*^(+*- B.3,2,8;(*^- C.3,2,4,2,2;(*^(- D.3,2,8;*^(- 链接：https://www.nowcoder.com/questionTerminal/3a42f70613294...
数据结构之栈的应用之四则运算
jiaomubai的博客
02-25 4339
对于四则运算，我们大家都很熟悉，不过就是“先乘除，后加减”的运算规则而已，如果遇上括号，则就先算括号里面的，仍然遵循“先乘除，后加减”的原则。比如，有个式子6*（5-4）+10/5，即为典型的四则运算，那么此式子我们平时怎么运算呢？当然是先算括号里面的5-4啊，于是此式子就变成了6*1+10/5。然后再根据运算规则加以变换就成了6+2，最后当然直接算了啊，结果为8。看起来很容易计算...
栈的应用：解析算术表达式
CCPP Blog
05-27 6301
类似于 1*2-3+4-(5-6)-2/4 的式子，我们称为算术表达式。下面我们利用栈这种数据结构来解析它，即用栈来辅助计算算术表达式。 首先我们得明确计算规则： 先左后右：从左算到右 先乘除，后加减 先括号内，后括号外 原理：
数据结构——栈（概念讲解、代码实现及应用）
sjl20021006的博客
07-26 1775
一、栈的定义和特征 栈是n个元素的有限序列，且只能在一端插入和删除的线性表，当n为0时，栈为空栈 下面我们来简单的分析一下栈的特征：假设我们向空栈中依次插入元素a1到an，那么由定义可知，删除这些元素的顺序只能是从an到a1，这说明栈具有后进先出（先进后出）的特征，也可以称为“first in last out”。 二、栈的某些术语和常用运算函数 栈顶：指的是插入和删除元素的一侧，也称为top。 栈底：栈的另一端，也叫...
栈的应用——加减乘除四则运算
weixin_52771283的博客
04-08 4160
栈的应用——加减乘除四则运算 栈 栈是特殊的线性表，相较于一般的线性表，在定义结构体时多了栈顶指针这一元素*（在链式表中为指针，在顺序表中表现为记录数组最后一个元素的下标的整型变量 int top）*。栈的操作也有别于通常的线性表，主要是通过栈顶指针对栈顶元素进行修改，包括了入栈、出栈、取栈顶元素等操作。由于栈通过栈顶指针进行操作，栈中元素表现出“后进先出”的特点，在程序设计时的应用十分广泛，其中加减乘除四则运算就是一个典型的例子。 a[maxsize] 栈顶指针 a[maxsize-1]
北大数据结构课讲义7.pptx
05-11
"这是一份来自北京大学的数据结构课程讲义，涵盖了栈和队列的相关知识。讲义详细讲解了栈的定义、顺序存储结构、链接存储结构及其操作实现，同时探讨了栈在算术表达式计算和递归中的应用。此外，还介绍了队列的概念...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值