• GO语言-栈的应用-表达式求值

    目录

    栈的应用-表达式求值

    1.实现功能

    2.需要注意的问题 

    2.1 解决运算符优先级问题

    2.2 如何利用栈解决表达式求值

    2.3 括号优先级和运算问题

    2.4 减号运算符的避坑指南

    3.代码实现

    3.1代码拆解详解

            3.1.1栈的定义和出栈、入栈操作

            3.1.2一些工具函数

            3.1.3逻辑实现主体

    3.2全量代码及执行结果

    先吐槽一下：学习的时候以为实现逻辑蛮清晰简单的。代码写起来好几百行...可能是自己的代码能力太弱了。

    栈的应用-表达式求值

    1.实现功能

    • 表达式可包含运算符号：+、-、*、/、(、)
    • 公式中的数字支持多位数
    • 如果公式有奇奇怪怪的字符则报错

    2.需要注意的问题 

    2.1 解决运算符优先级问题

    • 我们平时见到的表达式都是中缀表达式，就是运算符号在两个数之间的。如：1+2*3
    • 在利用栈进行表达式求值时，我们可以利用后缀表达式的思路来解决运算符的优先级问题。后缀表达式就是运算符号在两个数的后面。如：123*+（先做23*，再做16+）
    • 遇到优先级一样的两个运算符时，遵循从左至右计算。

    2.2 如何利用栈解决表达式求值

    • 准备两个栈，一个用于存储数字，另一个用于存储运算符。
    • 从左至右读取表达式。识别出数字和运算符，分别存入不同的栈。遍历数字时需要考虑多位数的情况。
    • 遇到运算数时，直接入栈，等待被计算。
    • 遇到运算符号时入栈，等待与下一个运算符号比较优先级。如果前一个符号优先级高，后一个符号优先级低，优先级低的入栈，优先级高的计算；如果前一个符号优先级低，后一个符号优先级高，优先级低的入栈，优先级高的继续与下一个符号比较（这里高优先级的乘除法还要与下一个符号比较的是考虑代码的扩展性，以后扩展可能会有更高优先级的运算符，如幂运算）。
    • 遇到右括号)时，需要循环出栈进行算术运算，直至遇到左括号(。
    • 表达式从左至右遍历完后，虽然过程中可以做算术运算，但栈中可能还会存在数字和运算符。最终需要将所有数字和运算符遍历出栈后计算。

    2.3 括号优先级和运算问题

    • 遇到左括号(时。左括号没有入栈时，其优先级比所有运算符都要高，需要入栈比较下一个运算符。
    • 遇到左括号(时。左括号已入栈，拿出来与下一个运算符比较时，其优先级比所有运算符都要低。
    • 遇到右括号)时。开始抛出栈中的运算符号，直至遇到栈中的左括(号。

    2.4 减号运算符的避坑指南

    2.4.1 问题描述：

    表达式中出现单个减号，按照2.2中的运算逻辑不会有什么问题。但是如果出现两个连续减号如(7-4/2-3)，其逻辑是：

            (1)第一个减号与除号比较，减号入栈，除号与下一个运算符比较；

            (2)遍历到第二个减号，比较后除号运算，第二个减号入栈，此时括号部分的表达式顺序变成了(7-2-3)；

            (3)遍历遇到右括号)，按照逻辑，循环出栈符号进行运算，此时就会先计算2-3=1，再计算7-1=6。计算结果错误。

    2.4.2 解决办法：

            可以声明一个标记变量，标记符号是否为减号。如果遇到了减号，将减号改为加号入栈，且下一个数字前添加负号再入栈，然后再将标记还原。

            此逻辑处理后，上述例子就会变成(7+(-2)+(-3))，(-2)+(-3)=-5，7+(-5)=2。计算结果正确。

    以上将中缀表达式转换为后缀表达式计算的时间复杂度可以达到O(n)

    3.代码实现

    3.1代码拆解详解

    3.1.1栈的定义和出栈、入栈操作

    考虑到表达式可能长度无法预估，和确保操作的便利性。我选择栈的链式存储结构-链栈来实现。

    1.链栈的定义

    1. type LinkStack struct {
    2. 	data interface{}
    3. 	next *LinkStack
    4. }

    2.栈的初始化、入栈、出栈

    1. //链栈初始化
    2. func initLinkStack() (linkStack *LinkStack) {
    3. 	//初始化链栈，新建链栈头节点
    4. 	linkStack = &LinkStack{
    5. 		data: "stackHeader",
    6. 		next: nil,
    7. 	}
    8. 	return linkStack
    9. }
    10.  
    11. //链栈-入栈
    12. func (s *LinkStack) push(v interface{}) {
    13. 	//链栈可先不考虑栈满，因为目前没有对栈做限制
    14.  
    15. 	pushNode := &LinkStack{
    16. 		data: v,
    17. 		next: nil,
    18. 	}
    19.  
    20. 	pushNode.next = s.next //入栈节点的next指向头节点的next节点
    21. 	s.next = pushNode      //头节点指向入栈节点
    22. }
    23.  
    24. //链栈-出栈
    25. func (s *LinkStack) pop() (interface{}, error) {
    26. 	//判断栈是否为空
    27. 	if s.next == nil {
    28. 		return "", errors.New("error: 栈为空")
    29. 	}
    30.  
    31. 	tmpTop := s.next
    32. 	v := tmpTop.data //出栈，获取节点的元素值
    33.  
    34. 	s.next = tmpTop.next //头节点指向原栈顶节点的下一个节点
    35. 	tmpTop.next = nil    //原栈顶节点指向nil
    36.  
    37. 	return v, nil
    38. }

    3.1.2一些工具函数

    1.判断运算符优先级

    1. //判断运算符号优先级
    2. func judgmentType(symbol string) int {
    3. 	switch symbol {
    4. 	case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9":
    5. 		return 0
    6. 	case "+", "-":
    7. 		return 1
    8. 	case "*", "/":
    9. 		return 2
    10. 	case "(":
    11. 		return 3
    12. 	case ")":
    13. 		return 4
    14. 	default:
    15. 		return -1
    16. 	}
    17. }

    2.判断运算符后对数字进行计算

    1. //判断运算符号并对数值进行计算
    2. func calculatedFormula(num1 int, num2 int, operator string) int {
    3. 	switch operator {
    4. 	case "+":
    5. 		fmt.Println("提示: 计算num1 + num2")
    6. 		return num1 + num2
    7. 	case "-":
    8. 		fmt.Println("提示: 计算num1 - num2")
    9. 		return num1 - num2
    10. 	case "*":
    11. 		fmt.Println("提示: 计算num1 * num2")
    12. 		return num1 * num2
    13. 	case "/":
    14. 		fmt.Println("提示: 计算num1 / num2")
    15. 		return num1 / num2
    16. 	default:
    17. 		fmt.Println("提示: 运算符号没有对应计算方法")
    18. 		return -9999
    19. 	}
    20. }

    3.1.3逻辑实现主体

    1.循环-遇到右括号)，或遍历完表达式后，循环出栈&计算数值

    1. //循环出栈symbolLinkStack中的符号，并进行运算。如遇到左括号(或栈为空时结束循环。
    2. func loopCalculationStack(numLinkStack *LinkStack, symbolLinkStack *LinkStack) {
    3. 	for {
    4. 		if symbolLinkStack.next == nil {
    5. 			fmt.Println("栈中无运算符号")
    6. 			break
    7. 		}
    8. 		tmpSymbol, _ := symbolLinkStack.pop()
    9. 		preSymbol := tmpSymbol.(string)
    10. 		fmt.Println("-旧符号出栈-", preSymbol)
    11.  
    12. 		if preSymbol == "(" {
    13. 			fmt.Println("提示: 遇到(, (出栈, 结束遍历符号栈的计算操作。")
    14. 			break
    15. 		} else {
    16. 			//两数根据符号进行运算，并入栈
    17. 			calculatedNum(numLinkStack, preSymbol)
    18. 		}
    19. 	}
    20. }

    2.单次-符号出栈&数字化计算

    1. //两数根据符号进行运算，并入栈
    2. func calculatedNum(numLinkStack *LinkStack, symbol string) {
    3. 	v2, err := numLinkStack.pop()
    4. 	if err != nil {
    5. 		fmt.Println(err)
    6. 	}
    7. 	v1, err := numLinkStack.pop()
    8. 	if err != nil {
    9. 		fmt.Println(err)
    10. 	}
    11.  
    12. 	num1 := v1.(int)
    13. 	num2 := v2.(int)
    14. 	fmt.Printf("-旧数字出栈- num2: %v; num1: %v\n", num2, num1)
    15.  
    16. 	calculatedValue := calculatedFormula(num1, num2, symbol)
    17. 	//计算数值入栈
    18. 	fmt.Println("-计算结果入栈-", calculatedValue)
    19. 	numLinkStack.push(calculatedValue)
    20. }

    3.遍历表达式后的出入栈主体逻辑

    实际代码

    1. func calculationFormulaResults(symbol string, numLinkStack *LinkStack, symbolLinkStack *LinkStack) (int, error) {
    2. 	fmt.Println("---遍历公式---")
    3. 	symbolTag := -1      //符号标记。判断数字前面符号是否为-，如果是减号，则将减号存为加号+，且数字取本身的负数。
    4. 	numTag := -1         //数字标记。判断是否为多位数
    5. 	symbolLoopTimes := 0 //记录公式循环到第几次
    6. 	for _, s := range symbol {
    7. 		symbolLoopTimes++
    8. 		fmt.Printf("----%v----\n", symbolLoopTimes)
    9. 		sType := judgmentType(string(s))
    10.  
    11. 		if sType == 0 {
    12. 			//公式中的数字直接入栈。如果遍历连续数字，说明是多位数，需要拼接多位数。
    13. 			var num int
    14. 			if numTag == 1 {
    15. 				prenumTmp, _ := numLinkStack.pop()
    16. 				prenumI := prenumTmp.(int)
    17. 				prenumA := strconv.Itoa(prenumI)
    18. 				fmt.Println(prenumA + string(s))
    19. 				num, _ = strconv.Atoi(prenumA + string(s))
    20. 			} else {
    21. 				num, _ = strconv.Atoi(string(s))
    22. 			}
    23.  
    24. 			//如果数字前的符号为减号，则改为加号，且数字变为负数。
    25. 			if symbolTag == 1 {
    26. 				symbolLinkStack.pop()     //减号出栈
    27. 				symbolLinkStack.push("+") //加号入栈
    28. 				fmt.Println("提示：数字前面为负号，执行加号入栈、数字加负号")
    29. 				num = -num     //数字添加负号
    30. 				symbolTag = -1 //操作结束，还原符号标记为-1
    31. 			}
    32.  
    33. 			fmt.Println("-新数字入栈-", num)
    34. 			numLinkStack.push(num)
    35.  
    36. 			numTag = 1
    37. 		} else if sType == 1 || sType == 2 {
    38. 			numTag = -1
    39. 			//符号如果为符号，修改符号标记为1
    40. 			if string(s) == "-" {
    41. 				symbolTag = 1
    42. 			}
    43.  
    44. 			if symbolLinkStack.next == nil {
    45. 				fmt.Println("-新符号入栈-", string(s))
    46. 				symbolLinkStack.push(string(s))
    47. 			} else {
    48. 				tmpSymbol := symbolLinkStack.next.data //查看栈顶符号
    49. 				preSymbol, _ := tmpSymbol.(string)
    50. 				nowSymbol := string(s)
    51.  
    52. 				//获取当前符合和前一个符号的优先级，如果符号是(，则(优先级最低
    53. 				var prePriority int
    54. 				if preSymbol == "(" {
    55. 					fmt.Println("-前一个符号是(-")
    56. 					prePriority = 0
    57. 				} else {
    58. 					prePriority = judgmentType(preSymbol)
    59. 				}
    60. 				nowPriority := judgmentType(nowSymbol)
    61.  
    62. 				if prePriority >= nowPriority { //如果前一个运算符优先级大于后一个运算符优先级
    63. 					fmt.Printf("提示: 栈顶符号%v优先级大于或等于当前符号%v优先级\n", preSymbol, nowSymbol)
    64. 					fmt.Println("-旧符号出栈-", preSymbol)
    65. 					symbolLinkStack.pop() //栈顶旧运算符弹出
    66. 					fmt.Println("-新符号入栈-", nowSymbol)
    67. 					symbolLinkStack.push(nowSymbol) //新运算符入栈
    68.  
    69. 					//两数根据符号进行运算，并入栈
    70. 					calculatedNum(numLinkStack, preSymbol)
    71.  
    72. 				} else if prePriority < nowPriority { //如果前一个运算符优先级小于后一个运算符优先级
    73. 					fmt.Printf("提示: 栈顶符号%v优先级小于当前符号%v优先级\n", preSymbol, nowSymbol)
    74. 					fmt.Println("-新符号入栈-", nowSymbol)
    75. 					symbolLinkStack.push(nowSymbol)
    76. 				}
    77. 			}
    78. 		} else if sType == 3 {
    79. 			fmt.Println("-左括号直接入栈-", string(s))
    80. 			symbolLinkStack.push(string(s))
    81. 			symbolTag = -1 //左括号前如有减号，还原符号标记为-1
    82. 		} else if sType == 4 {
    83. 			fmt.Println("-右括号不入栈-", string(s))
    84. 			//遇到),循环出栈所有栈中运算符并计算。遇到(时停止
    85. 			loopCalculationStack(numLinkStack, symbolLinkStack)
    86. 		} else {
    87. 			return -1, errors.New("公式格式不合法")
    88. 		}
    89. 	}
    90.  
    91. 	// 遍历完公式后，计算栈内剩余的元素
    92. 	fmt.Println("---公式遍历结束，计算栈中剩余元素---")
    93. 	loopCalculationStack(numLinkStack, symbolLinkStack)
    94.  
    95. 	//所有计算完成后，结果被存入numLinkStack，将结果出栈
    96. 	resultTmp, err := numLinkStack.pop()
    97. 	result := resultTmp.(int)
    98. 	if err != nil {
    99. 		fmt.Println("获取计算公式最终返回值时报错:", err)
    100. 	}
    101. 	return result, nil
    102. }

    伪代码解释

    1. func calculationFormulaResults(表达式, 存数字的栈, 存符号的栈) (计算结果, 报错信息) {
    2.     #初始化一些必要的标记和变量
    3.     
    4.     for 循环遍历表达式 {
    5.         if 如果遍历的是数字 {
    6.             数字直接入栈
    7.                 #1.考虑是否为多为数字
    8.                 #2.考虑数字前是否为减号
    9.         }else if 如果遍历的是加、减、乘、除号 {
    10.             if 如果符号栈是空的 {
    11.                 第一个符号就直接入栈
    12.             }else 栈不是空 {
    13.                 1.通过工具函数judgmentType，获取符号的优先级
    14.                     #如果出栈的前一个符号是左括号(，那么左括号的优先级比所有符号都低。
    15.  
    16.                 2.比较前一个符号和后一个符号的优先级
    17.                 if 前面符号的优先级 >= 当前符号的优先级 {
    18.                     1.用前一个符号计算两数的数值，然后数值入栈
    19.                     2.当前符号入栈
    20.                 } else if 前面符号的优先级 < 当前符号的优先级{
    21.                     1.当前符号入栈，等待与后面符号比较优先级
    22.                 }
    23.             }
    24.         }else if 如果遍历的是左括号( {
    25.             1.左括号直接入栈
    26.         }else if 如果遍历的是右括号 {
    27.             #右括号不入栈
    28.             1.遍历出栈并计算栈中的数字和符号，直到遇到左括号(
    29.         }else {
    30.             如果是其他字符，则报错公式格式不合法。
    31.         }
    32.     }
    33.  
    34.     #for循环遍历表达式结束
    35.     1.遍历数字和字符栈中剩余的所有元素，并进行计算。
    36.     2.retrun 计算结果
    37. }

    3.2全量代码及执行结果

    1. package main
    2.  
    3. import (
    4. 	"errors"
    5. 	"fmt"
    6. 	"strconv"
    7. )
    8.  
    9. type LinkStack struct {
    10. 	data interface{}
    11. 	next *LinkStack
    12. }
    13.  
    14. func main() {
    15. 	//初始化链栈
    16. 	fmt.Println("---初始化链栈---")
    17. 	numLinkStack := initLinkStack()
    18. 	symbolLinkStack := initLinkStack()
    19.  
    20. 	//定义一条四则运算
    21. 	// formula := "1+3*(4/2+1)+3*3+3/(7-6/3-2)*2"
    22. 	formula := "(43-40)*s(2-(8+3))"
    23. 	fmt.Println("计算公式: ", formula)
    24.  
    25. 	//计算
    26. 	result, err := calculationFormulaResults(formula, numLinkStack, symbolLinkStack)
    27. 	if err != nil {
    28. 		fmt.Println("error!!!: ", err)
    29. 	} else {
    30. 		fmt.Printf("\n\n---最终计算结果---\n")
    31. 		fmt.Println("计算公式: ", formula)
    32. 		fmt.Println("公式计算结果: ", result)
    33. 	}
    34.  
    35. }
    36.  
    37. func initLinkStack() (linkStack *LinkStack) {
    38. 	//初始化链栈，新建链栈头节点
    39. 	linkStack = &LinkStack{
    40. 		data: "stackHeader",
    41. 		next: nil,
    42. 	}
    43. 	return linkStack
    44. }
    45.  
    46. func (s *LinkStack) push(v interface{}) {
    47. 	//链栈可先不考虑栈满，因为目前没有对栈做限制
    48.  
    49. 	pushNode := &LinkStack{
    50. 		data: v,
    51. 		next: nil,
    52. 	}
    53.  
    54. 	pushNode.next = s.next //入栈节点的next指向头节点的next节点
    55. 	s.next = pushNode      //头节点指向入栈节点
    56. }
    57.  
    58. func (s *LinkStack) pop() (interface{}, error) {
    59. 	//判断栈是否为空
    60. 	if s.next == nil {
    61. 		return "", errors.New("error: 栈为空")
    62. 	}
    63.  
    64. 	tmpTop := s.next
    65. 	v := tmpTop.data //出栈，获取节点的元素值
    66.  
    67. 	s.next = tmpTop.next //头节点指向原栈顶节点的下一个节点
    68. 	tmpTop.next = nil    //原栈顶节点指向nil
    69.  
    70. 	return v, nil
    71. }
    72.  
    73. //判断运算符号优先级
    74. func judgmentType(symbol string) int {
    75. 	switch symbol {
    76. 	case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9":
    77. 		return 0
    78. 	case "+", "-":
    79. 		return 1
    80. 	case "*", "/":
    81. 		return 2
    82. 	case "(":
    83. 		return 3
    84. 	case ")":
    85. 		return 4
    86. 	default:
    87. 		return -1
    88. 	}
    89. }
    90.  
    91. //判断运算符号并对数值进行计算
    92. func calculatedFormula(num1 int, num2 int, operator string) int {
    93. 	switch operator {
    94. 	case "+":
    95. 		fmt.Println("提示: 计算num1 + num2")
    96. 		return num1 + num2
    97. 	case "-":
    98. 		fmt.Println("提示: 计算num1 - num2")
    99. 		return num1 - num2
    100. 	case "*":
    101. 		fmt.Println("提示: 计算num1 * num2")
    102. 		return num1 * num2
    103. 	case "/":
    104. 		fmt.Println("提示: 计算num1 / num2")
    105. 		return num1 / num2
    106. 	default:
    107. 		fmt.Println("提示: 运算符号没有对应计算方法")
    108. 		return -9999
    109. 	}
    110. }
    111.  
    112. func calculationFormulaResults(symbol string, numLinkStack *LinkStack, symbolLinkStack *LinkStack) (int, error) {
    113. 	fmt.Println("---遍历公式---")
    114. 	symbolTag := -1      //符号标记。判断数字前面符号是否为-，如果是减号，则将减号存为加号+，且数字取本身的负数。
    115. 	numTag := -1         //数字标记。判断是否为多位数
    116. 	symbolLoopTimes := 0 //记录公式循环到第几次
    117. 	for _, s := range symbol {
    118. 		symbolLoopTimes++
    119. 		fmt.Printf("----%v----\n", symbolLoopTimes)
    120. 		sType := judgmentType(string(s))
    121.  
    122. 		if sType == 0 {
    123. 			//公式中的数字直接入栈。如果遍历连续数字，说明是多位数，需要拼接多位数。
    124. 			var num int
    125. 			if numTag == 1 {
    126. 				prenumTmp, _ := numLinkStack.pop()
    127. 				prenumI := prenumTmp.(int)
    128. 				prenumA := strconv.Itoa(prenumI)
    129. 				fmt.Println(prenumA + string(s))
    130. 				num, _ = strconv.Atoi(prenumA + string(s))
    131. 			} else {
    132. 				num, _ = strconv.Atoi(string(s))
    133. 			}
    134.  
    135. 			//如果数字前的符号为减号，则改为加号，且数字变为负数。
    136. 			if symbolTag == 1 {
    137. 				symbolLinkStack.pop()     //减号出栈
    138. 				symbolLinkStack.push("+") //加号入栈
    139. 				fmt.Println("提示：数字前面为负号，执行加号入栈、数字加负号")
    140. 				num = -num     //数字添加负号
    141. 				symbolTag = -1 //操作结束，还原符号标记为-1
    142. 			}
    143.  
    144. 			fmt.Println("-新数字入栈-", num)
    145. 			numLinkStack.push(num)
    146.  
    147. 			numTag = 1
    148. 		} else if sType == 1 || sType == 2 {
    149. 			numTag = -1
    150. 			//符号如果为符号，修改符号标记为1
    151. 			if string(s) == "-" {
    152. 				symbolTag = 1
    153. 			}
    154.  
    155. 			if symbolLinkStack.next == nil {
    156. 				fmt.Println("-新符号入栈-", string(s))
    157. 				symbolLinkStack.push(string(s))
    158. 			} else {
    159. 				tmpSymbol := symbolLinkStack.next.data //查看栈顶符号
    160. 				preSymbol, _ := tmpSymbol.(string)
    161. 				nowSymbol := string(s)
    162.  
    163. 				//获取当前符合和前一个符号的优先级，如果符号是(，则(优先级最低
    164. 				var prePriority int
    165. 				if preSymbol == "(" {
    166. 					fmt.Println("-前一个符号是(-")
    167. 					prePriority = 0
    168. 				} else {
    169. 					prePriority = judgmentType(preSymbol)
    170. 				}
    171. 				nowPriority := judgmentType(nowSymbol)
    172.  
    173. 				if prePriority >= nowPriority { //如果前一个运算符优先级大于后一个运算符优先级
    174. 					fmt.Printf("提示: 栈顶符号%v优先级大于或等于当前符号%v优先级\n", preSymbol, nowSymbol)
    175. 					fmt.Println("-旧符号出栈-", preSymbol)
    176. 					symbolLinkStack.pop() //栈顶旧运算符弹出
    177. 					fmt.Println("-新符号入栈-", nowSymbol)
    178. 					symbolLinkStack.push(nowSymbol) //新运算符入栈
    179.  
    180. 					//两数根据符号进行运算，并入栈
    181. 					calculatedNum(numLinkStack, preSymbol)
    182.  
    183. 				} else if prePriority < nowPriority { //如果前一个运算符优先级小于后一个运算符优先级
    184. 					fmt.Printf("提示: 栈顶符号%v优先级小于当前符号%v优先级\n", preSymbol, nowSymbol)
    185. 					fmt.Println("-新符号入栈-", nowSymbol)
    186. 					symbolLinkStack.push(nowSymbol)
    187. 				}
    188. 			}
    189. 		} else if sType == 3 {
    190. 			fmt.Println("-左括号直接入栈-", string(s))
    191. 			symbolLinkStack.push(string(s))
    192. 			symbolTag = -1 //左括号前如有减号，还原符号标记为-1
    193. 		} else if sType == 4 {
    194. 			fmt.Println("-右括号不入栈-", string(s))
    195. 			//遇到),循环出栈所有栈中运算符并计算。遇到(时停止
    196. 			loopCalculationStack(numLinkStack, symbolLinkStack)
    197. 		} else {
    198. 			return -1, errors.New("公式格式不合法")
    199. 		}
    200. 	}
    201.  
    202. 	// 遍历完公式后，计算栈内剩余的元素
    203. 	fmt.Println("---公式遍历结束，计算栈中剩余元素---")
    204. 	loopCalculationStack(numLinkStack, symbolLinkStack)
    205.  
    206. 	//所有计算完成后，结果被存入numLinkStack，将结果出栈
    207. 	resultTmp, err := numLinkStack.pop()
    208. 	result := resultTmp.(int)
    209. 	if err != nil {
    210. 		fmt.Println("获取计算公式最终返回值时报错:", err)
    211. 	}
    212. 	return result, nil
    213. }
    214.  
    215. //循环出栈symbolLinkStack中的符号，并进行运算。如遇到左括号(或栈为空时结束循环。
    216. func loopCalculationStack(numLinkStack *LinkStack, symbolLinkStack *LinkStack) {
    217. 	for {
    218. 		if symbolLinkStack.next == nil {
    219. 			fmt.Println("栈中无运算符号")
    220. 			break
    221. 		}
    222. 		tmpSymbol, _ := symbolLinkStack.pop()
    223. 		preSymbol := tmpSymbol.(string)
    224. 		fmt.Println("-旧符号出栈-", preSymbol)
    225.  
    226. 		if preSymbol == "(" {
    227. 			fmt.Println("提示: 遇到(, (出栈, 结束遍历符号栈的计算操作。")
    228. 			break
    229. 		} else {
    230. 			//两数根据符号进行运算，并入栈
    231. 			calculatedNum(numLinkStack, preSymbol)
    232. 		}
    233. 	}
    234. }
    235.  
    236. //两数根据符号进行运算，并入栈
    237. func calculatedNum(numLinkStack *LinkStack, symbol string) {
    238. 	v2, err := numLinkStack.pop()
    239. 	if err != nil {
    240. 		fmt.Println(err)
    241. 	}
    242. 	v1, err := numLinkStack.pop()
    243. 	if err != nil {
    244. 		fmt.Println(err)
    245. 	}
    246.  
    247. 	num1 := v1.(int)
    248. 	num2 := v2.(int)
    249. 	fmt.Printf("-旧数字出栈- num2: %v; num1: %v\n", num2, num1)
    250.  
    251. 	calculatedValue := calculatedFormula(num1, num2, symbol)
    252. 	//计算数值入栈
    253. 	fmt.Println("-计算结果入栈-", calculatedValue)
    254. 	numLinkStack.push(calculatedValue)
    255. }

     

    由于我的代码中增加了很多输出提示类信息，所以感兴趣代码运行过程的话（数字、运算符出入栈和计算过程） ，可以看一下的详细输出。

    1. ---初始化链栈---
    2. 计算公式:  (43-40)*(2-(8+3))
    3. ---遍历公式---
    4. ----1----
    5. -左括号直接入栈- (
    6. ----2----
    7. -新数字入栈- 4
    8. ----3----
    9. 43
    10. -新数字入栈- 43
    11. ----4----
    12. -前一个符号是(-
    13. 提示: 栈顶符号(优先级小于当前符号-优先级
    14. -新符号入栈- -
    15. ----5----
    16. 提示：数字前面为负号，执行加号入栈、数字加负号
    17. -新数字入栈- -4
    18. ----6----
    19. -40
    20. -新数字入栈- -40
    21. ----7----
    22. -右括号不入栈- )
    23. -旧符号出栈- +
    24. -旧数字出栈- num2: -40; num1: 43
    25. 提示: 计算num1 + num2
    26. -计算结果入栈- 3
    27. -旧符号出栈- (
    28. 提示: 遇到(, (出栈, 结束遍历符号栈的计算操作。
    29. ----8----
    30. -新符号入栈- *
    31. ----9----
    32. -左括号直接入栈- (
    33. ----10----
    34. -新数字入栈- 2
    35. ----11----
    36. -前一个符号是(-
    37. 提示: 栈顶符号(优先级小于当前符号-优先级
    38. -新符号入栈- -
    39. ----12----
    40. -左括号直接入栈- (
    41. ----13----
    42. -新数字入栈- 8
    43. ----14----
    44. -前一个符号是(-
    45. 提示: 栈顶符号(优先级小于当前符号+优先级
    46. -新符号入栈- +
    47. ----15----
    48. -新数字入栈- 3
    49. ----16----
    50. -右括号不入栈- )
    51. -旧符号出栈- +
    52. -旧数字出栈- num2: 3; num1: 8
    53. 提示: 计算num1 + num2
    54. -计算结果入栈- 11
    55. -旧符号出栈- (
    56. 提示: 遇到(, (出栈, 结束遍历符号栈的计算操作。
    57. ----17----
    58. -右括号不入栈- )
    59. -旧符号出栈- -
    60. -旧数字出栈- num2: 11; num1: 2
    61. 提示: 计算num1 - num2
    62. -计算结果入栈- -9
    63. -旧符号出栈- (
    64. 提示: 遇到(, (出栈, 结束遍历符号栈的计算操作。
    65. ---公式遍历结束，计算栈中剩余元素---
    66. -旧符号出栈- *
    67. -旧数字出栈- num2: -9; num1: 3
    68. 提示: 计算num1 * num2
    69. -计算结果入栈- -27
    70. 栈中无运算符号
    71.  
    72.  
    73. ---最终计算结果---
    74. 计算公式:  (43-40)*(2-(8+3))
    75. 公式计算结果:  -27

  • 相关阅读:
    C++(20)：通过[[likely]]和[[unlikely]]优化编译switch
    [GUET-CTF2019]zips
    设计模式之策略模式
    antDesign Form表单校验（react）
    使用OpenCvSharp来计算图像的清晰度(可实现相机自动对焦)
    c语言tips-函数指针和指针函数
    联邦学习在移动通信网络智能化的应用
    connection_reset解决方案
    设计模式(3)-结构型模式
    『德不孤』Pytest框架 — 13、Pytest中Fixture装饰器（三）
  • 原文地址：https://blog.csdn.net/qq522044637/article/details/125935028