salesforce零基础学习（七十六）顺序栈的实现以及应用

数据结构中，针对线性表包含两种结构，一种是顺序线性表，一种是链表。顺序线性表适用于查询，时间复杂度为O(1),增删的时间复杂度为O(n).链表适用于增删，时间复杂度为O(1),查询的时间复杂度为O(n).

栈可以说是特殊的线性表，因为栈拥有线性表的基础特征基础上，有一些特殊的要求，比如后进先出，即每次插入的元素只能放在栈顶，每次弹出值也只能弹出栈顶。同样的，栈分成顺序栈和链栈。本篇内容为顺序栈的实现以及简单应用。

顺序栈可以应用到很多的地方，比如递归运算，语法检查（比如括号匹配问题），数值转换（十进制转换成其他进制），四则运算等等。

栈在java中有现有的封装的类，但是在apex中貌似没有已经封装的类，我们可以针对其功能进行自行的封装。顺序栈是顺序线性表的特殊情况，所以说实现上可以使用数组来实现。

一.顺序栈的实现

针对栈的类应该有以下的构造函数及方法：

1.构造函数：设计成了三种，无参设置默认长度，传入默认长度，以及传默认长度并且指定此栈为固定长度还是动态扩展；

2.empty：判断此栈是否为空栈；

3.peek：返回栈顶元素，栈顶元素指针不减一；

4.push：入栈，栈顶元素指针加一；

5.pop：出栈，栈顶元素减一；

6.search：搜索obj在栈的位置，大于0说明存在；

7.toString：重写stack默认返回的内容。

顺序栈类应该还有其他的方法，比如destroy等，有兴趣的可以自行填充。

Stack类的代码设计如下：

 public without sharing class Stack {

     //数据集
     private Object[] datas{get;set;}
     //栈最大容量
     private Integer maxSize{get;set;}
     //栈顶指针
     private Integer topIndex{get;set;}
     //是否允许动态扩展栈的容量
     private Boolean allowExtension{get;set;}
     //默认扩展容量大小
     private final Integer DEFAULT_EXTENSION_SIZE = 5;

     public Stack() {
         this(5);
     }

     public Stack(Integer stackSize) {
         this(stackSize,false);
     }

     public Stack(Integer stackSize,Boolean allowStackExtension) {
         if(stackSize > 0) {
             datas = new Object[stackSize];
             maxSize = stackSize;
             topIndex = -1;
             allowExtension = allowStackExtension;
         } else {
             //TODO throw exception
             //栈容量必须大于0
             throw new StackException('栈容量必须大于0');
         }
     }

     public Boolean empty() {
         return topIndex == -1 ? true : false;
     }

     public Object peek() {
         if(topIndex == -1) {
             //TODO throw exception
             //空栈无法获取栈顶值
             throw new StackException('空栈无法获取栈顶值');
         }
         return datas[topIndex];
     }

     public Object push(Object obj) {
         if(topIndex == maxSize - 1) {
             if(allowExtension) {
                 datas = copyOf(maxSize + DEFAULT_EXTENSION_SIZE);
             } else {
                 //TODO 栈已满，无法入栈
                 throw new StackException('栈已满，无法入栈');
             }
         }
         datas[++topIndex] = obj;
         return obj;
     }

     public Object pop() {
         if(topIndex == -1) {
             //TODO 空栈，无法出栈
             throw new StackException('空栈无法获取栈顶值');
         }

         Object popObj = datas[topIndex];
         datas[topIndex] = null;
         topIndex -=1;
         return popObj;
     }

     public Integer search(Object obj) {
         Integer i=topIndex;
         while(i != -1){
             if(datas[i] != obj) {
                 i--;
             } else {
                 break;
             }
         }
         return i + 1;
     }

     private Object[] copyOf(Integer newStackSize) {
         Object[] tempObjs = new Object[newStackSize];
         for(Integer i = 0;i < datas.size();i++) {
             tempObjs[i] = datas[i];
         }
         return tempObjs;
     }

     override public String toString() {
         List<Object> objs = new List<Object>();
         for(Object obj : datas) {
             if(obj != null) {
                 objs.add(obj);
             }
         }
         return String.valueOf(objs);
     }

     public class StackException extends Exception{

     }
 }

二.顺序栈的简单应用

顺序栈可以应用到很多场景，demo来一个简单的四则运算。此四则运算考虑的东西比较少，没有对细节进行完善，目前仅支持 + - * /  以及整数的操作，返回的结果为double类型的值。

来一个简单的四则运算的例子：1 + 2 + 3 * 4 - 8 / 5 * 2 + 3 - 1

此表达式为中缀表示法--运算符均在数字中间。我们需要以一定的规则转换成后缀表达式，这便用到了栈的知识。

1).中缀表达式转换成后缀表达式

中缀表达式转换成后缀表达式规则为将运算符放在空栈里面：

1.当栈为空情况下，第一个运算符入栈；

2.当前的运算符优先级如果比栈顶元素高，则入栈；

3.当前的运算符如果比栈顶元素低，则将栈中从栈顶开始所有连续的高于当前运算符的元素出栈，然后将当前运算符入栈；

4.当表达式结束后，将栈中所有的元素弹出。

原始表达式：1 + 2 + 3 * 4 - 8 / 5 * 2 + 3 - 1

第一轮：1是数字，所以不进入栈，直接弹出；　　内容1

第二轮：+是运算符，因为栈为空，所以直接入栈　　内容1      栈：+

第三轮：2是数字，所以不进入栈，直接弹出；　　内容1 2      栈： +

第四轮：+是运算符，优先级不如栈顶元素，将栈顶元素+弹出，并将当前的+入栈　　内容1 2 +    栈：+

第五轮：3是数字，不进入栈，直接弹出　　内容1 2 + 3     栈：+

第六轮：*是运算符，因为优先级比栈顶元素+高，所以入栈　　内容1 2 + 3     栈：+ *

第七轮：4是数字，不进入栈，直接弹出　　内容1 2 + 3 4   栈：+ *

第八轮：-是运算符，因为优先级比栈顶元素* 以及相邻元素+优先级低，所以* + 出栈，-入栈　　内容1 2 + 3 4 * +    栈：-

第九轮：8是数字，不进入栈，直接弹出　　内容1 2 + 3 4 * + 8   栈：-

第十轮：/是运算符，因为优先级比栈顶元素-高，所以入栈　　内容1 2 + 3 4 * + 8   栈：- /

第十一轮：5是数字，不进入栈，直接弹出　　内容1 2 + 3 4 * + 8 5   栈：- /

第十二轮：*是运算符，优先级比栈顶元素低，但是比-高，所以/出栈，*入栈　　内容1 2 + 3 4 * + 8 5 /   栈：- *

第十三轮：2是数字，不进入栈，直接弹出　　内容1 2 + 3 4 * + 8 5 / 2  栈：- *

第十四轮：+是运算符，优先级比* - 低，所以 * -出栈，+入栈 　　内容1 2 + 3 4 * + 8 5 / 2 * -  栈： +

第十五轮：3是数字，不进入栈，直接弹出　　内容1 2 + 3 4 * + 8 5 / 2 * - 3 栈： +

第十六轮：-是运算符，优先级比+低，所以+出栈，-入栈　　内容1 2 + 3 4 * + 8 5 / 2 * - 3 + 栈： -

第十七轮：1是数字，不进入栈，直接弹出　　内容1 2 + 3 4 * + 8 5 / 2 * - 3 + 1 栈： -

第十八轮，表达式已结束，将栈所有元素弹出　　内容1 2 + 3 4 * + 8 5 / 2 * - 3 + 1 -

所以此表达式转换成后缀表达式的结果为： 1 2 + 3 4 * + 8 5 / 2 * - 3 + 1 -

 2）后栈表达式求结果

后栈表达式为运算符在数字的后面，规则为将数字放到栈里，遇到运算符则把栈顶的前两个元素拿出来进行运算，并把结果值放入栈顶，重复操作，直到表达式运算到最后，栈里只有一个值，即最终的结果。

原始表达式：1 2 + 3 4 * + 8 5 / 2 * - 3 + 1 -

第一轮：1是数字，当前栈为空栈，入栈 　　栈 ： 1

第二轮：2是数字，入栈　　栈：1 2

第三轮：+是运算符，弹出位于栈顶前两个内容进行相加，结果为3入栈　　栈：3

第四轮：3是数字，入栈　　栈：3 3

第四轮：4是数字，入栈　　栈：3 3 4

第五轮：*是运算符，弹出位于栈顶前两个内容进行相乘，结果为12入栈　　栈：3 12

第六轮：+是运算符，弹出位于栈顶前两个内容进行相加，结果为15入栈　　栈：15

第七轮：8是数字，入栈　　栈：15 8

第八轮：5是数字，入栈　　栈： 15 8 5

第九轮：/是运算符，弹出位于栈顶前两个内容进行相除，结果为1.6入栈　　栈：15 1.6

第十轮：2是数字，入栈　　栈： 15 1.6 2

第十一轮：*是运算符，弹出位于栈顶前两个内容进行相乘，结果为3.2入栈　　栈：15 3.2

第十二轮：-是运算符，弹出位于栈顶前两个内容进行相减，结果为11.8入栈　　栈：11.8

第十三轮：3是数字，入栈　　栈：11.8 3

第十四轮：+是运算符，弹出位于栈顶前两个内容进行相加，结果为14.8入栈　　栈：14.8

第十五轮：1是数字，入栈　　栈：14.8 1

第十六轮：-是运算符，弹出位于栈顶前两个内容进行相减，结果为15.8入栈　　栈：13.8

运算结束，结果为13.8

代码实现：

 public with sharing class MathUtil {

     private static Set<String> symbolSet = new Set<String>{'+','-','*','/'};

     private static Integer compareTo(String stackTopValue,String compareValue) {
         Integer result;
         if(stackTopValue == '+' || stackTopValue == '-') {
             if(compareValue == '+' || compareValue == '-') {
                 result = -1;
             } else if(compareValue == '*' || compareValue == '/') {
                 result = 1;
             }
         } else if(stackTopValue == '*' || stackTopValue == '/') {
             return -1;
         }
         return result;
     }

     //将表达式从中缀表示法转换成后缀表示法
     //eg ： 1 + 2 + 3 * 4 - 10 / 5 * 2 + 3 - 1    ==>  1 2 + 3 4 * + 10 5 / 2 * - 3+ 1-
     private static String transferToPostFixNotation(String inFixNotationContent) {
         String result = '';
         Stack symbolStack = new Stack(10,true);
         Boolean previousCharacterIsNumric = true;
         Integer[] chars = inFixNotationContent.getChars();
         for(Integer charInteger : chars) {
             String tempChar = String.fromCharArray(new List<Integer>{charInteger});

             if(symbolSet.contains(tempChar)) {
                 if(symbolStack.empty()) {
                     symbolStack.push(tempChar);
                 } else {
                     String stackTopValue = (String)symbolStack.peek();
                     if(compareTo(stackTopValue,tempChar) > 0) {
                         symbolStack.push(tempChar);
                     } else {
                         Boolean enablePop = true;
                         //将所有栈中优先级比当前的符号高的出栈
                         while(enablePop) {
                             if(!symbolStack.empty()) {
                                 String symbolStackPop = (String)symbolStack.peek();
                                 if(compareTo(symbolStackPop,tempChar) < 0) {
                                     symbolStackPop = (String)symbolStack.pop();
                                     result += symbolStackPop;
                                 } else {
                                     enablePop = false;
                                 }
                             } else {
                                 enablePop = false;
                             }
                         }
                         symbolStack.push(tempChar);
                     }
                 }
             } else if(tempChar.isWhitespace()) {
                 continue;
             } else {
                 if(previousCharacterIsNumric) {
                     result += tempChar;
                 } else {
                     result += ' ' + tempChar;
                 }
             }
             if(tempChar.isNumeric() || tempChar == '.') {
                 previousCharacterIsNumric = true;
             } else {
                 previousCharacterIsNumric = false;
             }
         }
         while(!symbolStack.empty()) {
             result += (String)symbolStack.pop();
         }
         return result;
     }

     public static Double calculate(String inFixNotationContent) {
         String postFixNotationContent = transferToPostFixNotation(inFixNotationContent);
         Stack numricStack = new Stack(10,true);
         Integer[] chars = postFixNotationContent.getChars();
         Boolean previousCharacterIsNumric = true;
         for(Integer charInteger : chars) {
             String character = String.fromCharArray(new List<Integer>{charInteger});
             if(character.isNumeric()) {
                 if(!numricStack.empty()) {
                     if(previousCharacterIsNumric) {
                         character = (String)numricStack.pop() + character;
                     }
                 }
                 numricStack.push(character);
             } else if(character == ' ') {
                 previousCharacterIsNumric = false;
                 continue;
             } else if(symbolSet.contains(character)){
                 Double number1 = Double.valueOf(numricStack.pop());
                 Double number2 = Double.valueOf(numricStack.pop());
                 Double result;
                 if(character.equals('+')) {
                     result = number2 + number1;
                 } else if(character.equals('-')) {
                     result = number2 - number1;
                 } else if(character.equals('*')) {
                     result = number2 * number1;
                 } else if(character.equals('/')) {
                     result = number2 / number1;
                 }
                 numricStack.push(String.valueOf(result));
             }
             if(character.isNumeric()) {
                 previousCharacterIsNumric = true;
             } else {
                 previousCharacterIsNumric = false;
             }
         }
         String result = numricStack.toString().remove('(').remove(')');
         return Double.valueOf(result);
     }

 }

执行结果：

String test = '1 + 2 + 3 * 4 - 8 / 5 * 2 + 3 - 1';
System.debug('result :' + MathUtil.calculate(test));

总结：此篇只是简单的进行了顺序栈的实现，有好多方法没有封装，有用到顺序栈的小伙伴可以自行优化。四则运算没有考虑表达式校验，小数情况以及具有括号情况，有兴趣的自行优化。篇中有错误的地方欢迎指出，有问题欢迎留言。