栈

最新推荐文章于 2023-01-19 00:47:49 发布
最新推荐文章于 2023-01-19 00:47:49 发布
阅读量193 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 栈 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48276298/article/details/115742486
版权

基本介绍

  • 栈的英文为stack,是一个先进后出（FILO）的有序列表。
  • 栈时限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表，允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）.
  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
    出栈(Pop)和入栈(Push)的操作图解如下所示
    在这里插入图片描述

应用场景

  • 子程序的调用：在跳往子程序之前，会先将下一个指令的地址存到堆栈中，直到子程序执行完成后将地址取出。
  • 处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入栈中。
  • 表达式的转换【中缀表达式转后缀表达式】与求值。
  • 二叉树的遍历
  • 图形的深度优先搜索。

数组实现栈

使用数组实现栈的思路分析示意图如下：
在这里插入图片描述
代码实现如下：

/***
 * @Auther: hs
 * @Date: 2020/5/20 12:03 
 * 使用数组模拟栈
 */
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 "exit":
                    scanner.close();
                    loop=false;
                    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;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~~");
    }
}

//定义一个ArrayStack表示栈
class ArrayStack{
    private int maxSize;    //栈的大小
    private int[] stack;    //数组，使用它模拟栈，数据放在该数组中
    private int top=-1;    //栈顶

    public ArrayStack(int maxSize){
        this.maxSize=maxSize;
        stack=new int[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]);
        }
    }
}

栈实现综合计算器(中缀表达式)

使用栈来实现计算器，思路分析示意图如下：
在这里插入图片描述
代码实现如下：

/***
 * @Auther: hs
 * @Date: 2020/5/23 12:03 
 * 中缀表达式计算表达式的结果步骤
 * 步骤：
 * 1.创建两个栈，一个数栈，一个运算符栈
 * 2.遍历表达式，如果当前字符是运算符
 * 2.1如果此时运算符栈为空，则直接把当前字符压入到运算符栈中
 * 2.2如果此时运算符栈不为空，并且当前字符的优先级大于运算符栈顶元素，则直接加入到运算符栈
 * 2.3如果此时运算符栈不为空，并且当前字符的优先级小于运算符栈顶元素，则将数栈pop出两个数，
 *      符号栈pop出一个运算符，计算，将结果加入到数栈，并将当前的字符加入到运算符栈中
 * 3.如果当前字符是数
 * 3.1判断当前是否是表达式最后一个字符，如果是，则直接加入到数栈中国
 * 3.2如果不是表达式最后一个字符，则往后查看下一个字符是否是数字，如果是数字，则进行拼接，如果不是则将拼接的结果加入到数栈
 * 4.依次将数栈pop出两个数，运算符栈pop出一个运算符，进行计算，并将结果加入到数栈，直到数栈中只剩下最终的计算结果
 */
public class Calculator {
    public static void main(String[] args) {
        //根据前面的思路，完成表达式的运算
        String expression="70+2*6-2";
        //创建两个栈，数栈、符号栈
        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=' ';
        String keepNum="";
        while (true){
            //获取当前遍历的字符
            ch=expression.substring(index,index+1).charAt(0);
            if(operStack.isOper(ch)){
                //如果是运算符
                if(!operStack.isEmpty()){
                    if(operStack.priority(ch)<=operStack.priority(operStack.peek())){
                        num1=numStack.pop();
                        num2=numStack.pop();
                        oper=operStack.pop();
                        res=operStack.cal(num1,num2,oper);
                        numStack.push(res);
                        operStack.push(ch);
                    }else {
                        operStack.push(ch);
                    }
                }else {
                    operStack.push(ch);
                }
            }else {
                //如果是数，处理多位数的问题
                keepNum+=ch;
                if(index==expression.length()-1){
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    if(operStack.isOper(expression.substring(index+1,index+2).charAt(0))){
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum="";
                    }
                }

            }
            index++;
            if(index>=expression.length()){
                break;
            }
        }

        while (true){
            if(operStack.isEmpty()){
                break;
            }
            num1=numStack.pop();
            num2=numStack.pop();
            oper=operStack.pop();
            res=operStack.cal(num1,num2,oper);
            numStack.push(res);

        }

        System.out.println("计算结果= "+numStack.pop());


    }
}

//创建一个栈
class ArrayStack2{
    private int maxSize;
    private int[] stack;
    private int top=-1;

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

    /**
     * 查看栈顶元素
     */
    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 show(){
        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;
        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;
    }
}

逆波兰计算器

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

  • 输入一个逆波兰表达式（后缀表达式），使用栈，计算其结果。
  • 支持小括号和多位整数。
  • 思路分=分析如下：
    在这里插入图片描述
    代码如下：
package com.atguigu.stack;

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

public class PolandNotation {

	public static void main(String[] args) {
		//先定义给逆波兰表达式
		//(30+4)×5-6  => 30 4 + 5 × 6 - => 164
		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + 
		//测试 
		//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
		//String suffixExpression = "30 4 + 5 * 6 -";
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
		//思路
		//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
		//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList=" + list);
		int res = calculate(list);
		System.out.println("计算的结果是=" + res); 
	}
		 
	//将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
	public static List<String> getListString(String suffixExpression) {
		//将 suffixExpression 分割
		String[] split = suffixExpression.split(" ");
		List<String> list = new ArrayList<String>();
		for(String ele: split) {
			list.add(ele);
		}
		return list;
		
	}
	
	//完成对逆波兰表达式的运算
	/*
	 * 1)从左至右扫描，将3和4压入堆栈；
		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
		3)将5入栈；
		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
		5)将6入栈；
		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
	 */
	
	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);
			}
			
		}
		//最后留在stack中的数据是运算结果
		return Integer.parseInt(stack.pop());
	}

}

中缀表达式转后缀表达式

后缀表达式适合计算式进行运算，但是却不太容易写出来，尤其是表达式很长的情况下，因此我们需要将中缀表达式转为后缀表达式
具体步骤如下：
1.初始化两个栈：运算符栈s1和存储中间结果的栈s2
2.从左至右扫描中缀表达式
3.遇到操作数，将其压入s2
4.遇到运算符时，比较其与s1栈顶运算符的优先级

  • 4.1如果s1为空，或者栈顶运算符为左括号"("，则直接将此运算符入栈s1
  • 4.2否则，若优先级比栈顶运算符的高，也将其压入栈s1
  • 4.3否则，将s1栈顶的运算符弹出压入到s2中，再次转到4.1与s1中新的栈顶元素相比较

5.遇到运算符时：

  • 如果时左括号"("，则直接压入s1
  • 如果是右括号")"，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃

6.重复步骤2至步骤5，直到表达式的最右边
7.将s1中剩下的的运算符依次弹出压入到s2
8.依次弹出s2栈中的元素，结果的逆序即为中缀表达式对应的后缀表达式

举例说明
将中缀表达式"1+((2+3)x4)-5"转换为后缀表达式的过程如下：
在这里插入图片描述

代码演示如下：

public class PolandNotation {

	public static void main(String[] args) {
		
		
		//完成将一个中缀表达式转成后缀表达式的功能
		//说明
		//1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
		//2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
		//   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
		//3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
		//   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
		
		String expression = "1+((2+3)*4)-5";//注意表达式 
		List<String> infixExpressionList = toInfixExpressionList(expression);
		System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
		List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
		System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–] 
		
		System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
		
		
		
		/*

		//先定义给逆波兰表达式
		//(30+4)×5-6  => 30 4 + 5 × 6 - => 164
		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + 
		//测试 
		//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
		//String suffixExpression = "30 4 + 5 * 6 -";
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
		//思路
		//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
		//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList=" + list);
		int res = calculate(list);
		System.out.println("计算的结果是=" + res);

		*/
	}
	
	
	
	//即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
	//方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
	public static List<String> parseSuffixExpreesionList(List<String> ls) {
		//定义两个栈
		Stack<String> s1 = new Stack<String>(); // 符号栈
		//说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
		//因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
		//Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
		List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
		
		//遍历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中，再次转到(4.1)与s1中新的栈顶运算符相比较
				//问题：我们缺少一个比较优先级高低的方法
				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
		
	}
	
	//方法：将 中缀表达式转成对应的List
	//  s="1+((2+3)×4)-5";
	public static List<String> toInfixExpressionList(String s) {
		//定义一个List,存放中缀表达式 对应的内容
		List<String> ls = new ArrayList<String>();
		int i = 0; //这时是一个指针，用于遍历 中缀表达式字符串
		String str; // 对多位数的拼接
		char c; // 每遍历到一个字符，就放入到c
		do {
			//如果c是一个非数字，我需要加入到ls
			if((c=s.charAt(i)) < 48 ||  (c=s.charAt(i)) > 57) {
				ls.add("" + c);
				i++; //i需要后移
			} else { //如果是一个数，需要考虑多位数
				str = ""; //先将str 置成"" '0'[48]->'9'[57]
				while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) {
					str += c;//拼接
					i++;
				}
				ls.add(str);
			}
		}while(i < s.length());
		return ls;//返回
	}
	
	//将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
	public static List<String> getListString(String suffixExpression) {
		//将 suffixExpression 分割
		String[] split = suffixExpression.split(" ");
		List<String> list = new ArrayList<String>();
		for(String ele: split) {
			list.add(ele);
		}
		return list;
		
	}
	
	//完成对逆波兰表达式的运算
	/*
	 * 1)从左至右扫描，将3和4压入堆栈；
		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
		3)将5入栈；
		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
		5)将6入栈；
		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
	 */
	
	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);
			}
			
		}
		//最后留在stack中的数据是运算结果
		return Integer.parseInt(stack.pop());
	}

}

//编写一个类 Operation 可以返回一个运算符 对应的优先级
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 operation) {
		int result = 0;
		switch (operation) {
		case "+":
			result = ADD;
			break;
		case "-":
			result = SUB;
			break;
		case "*":
			result = MUL;
			break;
		case "/":
			result = DIV;
			break;
		default:
			System.out.println("不存在该运算符" + operation);
			break;
		}
		return result;
	}
}
努力更文的小白
关注
专栏目录
Linux 中的各种栈：进程栈 线程栈 内核栈 中断栈
05-06
在Linux系统中，栈可以分为进程栈、线程栈、内核栈以及中断栈。 首先，我们需要了解栈（Stack）的基本概念。栈是一种后进先出（LIFO, Last In First Out）的数据结构，它允许数据被存储和检索，但只允许在一段称为...
两个栈空间共享，栈满打印
04-16
标题中的“两个栈空间共享，栈满打印”指的是在C++编程中实现一个特殊的栈结构，其中两个栈共享同一个内存空间。这个结构可以用于存储整数序列中的奇数和偶数，当任一栈达到其最大容量（即“栈满”状态）时，程序会...
利用栈对表达式进行求值，+表示将后面的字母压进栈，-表示弹出栈顶字母并打印
qq_41791653的博客
04-26 283
package p414; public class StackTest { private Stack &lt;Character&gt;stack = new Stack&lt;Character&gt;(); public void useStack(String s){ for(int i=0;i&lt;s.length();i++){ char c=s.charAt(i)...
数据结构与算法之栈
oLengNuanZiZhi12的博客
02-13 944
栈1>栈的基本介绍1.1、栈的实际需求1.2、栈的基本性质1.3、栈的应用场景2>数组模拟栈2.1、代码思路2.2、代码实现2.3>课后作业3>栈实现综合计算器(中缀表达式)3.1、代码思路3.2、代码实现4>前缀 中缀 后缀表达式4.1、前缀表达式(波兰表达式)4.1.1、前缀表达式4.1.2、前缀表达式的计算机求值4.2、中缀表达式4.3、后缀表达式4.3.1、后缀表达式4.3.2、后缀表达式的计算机求值5>逆波兰计算器5.1、计算器说明5.2、代码思路5.3、代码实
数据结构和算法（七）栈 Stack
思想累积的博客
06-12 242
1、简介 栈（Stack）是一个先进后出的有序列表 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端为变化的一端，成为栈顶（Top），另一端为固定的一端，称为栈底（Bottom） 根据栈的定义，最先放入栈的元素在栈底，最后放入的元素在栈顶，删除元素刚好想反，最后放入的元素最先删除，最先放入的元素最后删除 出栈（pop）和入栈（push） 2、应用场景 子程序的调用，在跳往子程序前，先将下个指令的地址存入栈中，直到子程序执行完后再将地址取出，回到原来的程序中
数据结构——栈的详解
热门推荐
晴空๓
04-20 8万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
【Unity3D】Unity3D技术栈
最新发布
little_fat_sheep
01-19 4万+
本文梳理了笔者在学习 Unity3D 的过程中，对 Unity3D 的理解和学习路线，以帮助读者循序渐进地学习 Unity3D，后续笔者仍会持续更新 Unity3D 相关技术栈，并同步到本文中。
栈及栈的应用举例
qq_44392492的博客
08-19 4332
第5章 栈1、前言2、栈的介绍和应用场景2.1 栈的基本介绍2.2 栈的应用场景3、栈的思路分析及实现3.1 数组模拟实现栈3.2 链表模拟实现栈4、栈实现计算器（中缀）4.1 思路分析4.2 代码实现 1、前言 先看一个例子，请输入一个表达式 计算式:[7 * 2 * 25+1-5+3-3] 点击计算【如下图】 请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，
顺序栈和链栈(C语言)
weixin_43405004的博客
10-17 2377
简述 栈(Stack):是限制在表的一端进行插入和删除操作的线性表。又称为后进先出LIFO(Last In First Out)或先进后出FILO(First In Last Out)线性表。 栈顶(Top):允许进行插入、删除操作的一端，又称为表尾。用栈顶指针(top)来指示栈顶元素。 栈底(Bottom):是固定端，又称为表头。 空栈:当表中没有元素时称为空栈。 一般将插入和删除操作称为入栈和出栈。 顺序栈和链栈 栈是一种线性表，所以栈也有线性表的两种存储结构（顺序存储结构和链式存储结构）。 栈的顺序存
Java数据结构与算法——栈
★★光亭★★
03-13 9179
Java数据结构与算法——栈
Python——栈
XQC_KKK的博客
05-01 1585
首先用一张图来表示栈： 栈只有一个开口，在这个开口完成入栈和出栈。并且入栈是按照顺序堆叠，先入栈的被“叠”在最下面，后入栈的在上面。想要最下面的出来，必须它的上面没有东西。即先进后出，后进先出。 下面通过Python实现栈 # 用Python实现栈 class Stack: def __init__(self): self.items = [] def isEmpty(self): return self.items == [] def push
LwIP协议栈源码详解.pdf
05-03
"LwIP协议栈源码详解" LwIP协议栈是 lightweight TCP/IP 协议栈的实现，它是一种轻量级、开源的嵌入式系统网络协议栈，广泛应用于嵌入式系统、物联网、自动化控制等领域。LwIP 协议栈的设计目标是提供一个小巧、...
数据结构栈的实验报告.doc
07-11
实验报告的主题是关于数据结构中的顺序栈的基本操作，主要涵盖了栈的初始化、进栈、出栈等核心概念。顺序栈是一种特殊的线性表，它的特点是只允许在一端进行插入和删除操作，这一端称为栈顶。 1. **栈的类型定义**...
数据结构顺序栈验证实验报告.pdf
07-11
数据结构中的顺序栈是一种特殊的线性表，它具有后进先出（LIFO）的特点，即最后进入的元素最先离开。在本实验报告中，学生通过编写C语言代码来理解和验证顺序栈的操作特性。 首先，实验的目标是让学生掌握栈的顺序...
八皇后问题
weixin_48276298的博客
05-23 1万+
基本介绍 在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。问有多少种摆法。 八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。 问题分析 设八个皇后为xi，分别在第i行( I = 1，2，3，4……，8)。 问题的解状态：可
动态规划——01背包问题
weixin_48276298的博客
05-22 896
基本介绍 背包问题：有一个背包，容量为4磅，现有如下物品 1）要求达到的目标为装入的背包的总价值最大，并且重量不超出。 2）要求装入的物品不能重复 分析 背包问题主要指一个给定容量的背包，若干具有一定价值和重量的物品，如何选择物品放入背包使得物品放入背包的价值最大，其中又分为01背包和完全背包（完全背包指的是：每种物品都有无限件可用）。而01背包指的是每个物品最多放一个，并且完全背包可以转化为01背包问题。 算法的主要思想：利用动态规划来解决，每次遍历的第i个物品，根据w[i]和v[i]来确定是否需要将该
希尔排序
weixin_48276298的博客
05-04 194
基本介绍 希尔排序是希尔于1959年提出的一种排序算法，希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。 基本思想 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，魅族包含的关键词越来越多，当增量减少至1时，整个文件恰被分组成一组，算法终止。 希尔排序算法示意图如下： 应用实例 希尔排序对有序序列在插入时采用交换方法，代码演示如下： // 希尔排序时， 对有序序列在插入时采用交换法, // 思路(算法) ===&gt
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值