栈和队列的应用

Posted 2020-07-08

1．栈常见应用

1.1 括号匹配

问题描述：假设表达有两种符号：圆的和方的，嵌套的顺序任意，判断嵌套是否正确，如 ([]()) 或 [[()]]均为正确，而 [(]) 或 (()] 均为不正确。

算法描述：

   （1）初始化一个空栈，顺序读入括号；

   （2）若是左括号直接进栈；

   （3）若是右括号，先出栈一个元素比较是否与其匹配，如匹配则继续比较下一个括号，若不匹配则返回匹配失败；

   （4）最后若栈不为空，说明还有没匹配的括号，匹配失败，否则匹配成功。

/**
 * 检查括号是否匹配
 * @param match 待匹配字符串
 * @return true 匹配成功，false 匹配失败
 */
public static boolean isMatching(String match){
    char[] braces = match.trim().toCharArray();
    for(char ch : braces){
        if(ch == ‘[‘ || ch == ‘(‘){
            stack.push(ch);
        } else if(ch == ‘]‘){
            char t = stack.pop();
            if(‘[‘ == t){
                continue;
            } else {
                return false;
            }
        } else if(ch == ‘)‘){
            char c = stack.pop();
            if(‘(‘ == c){
                continue;
            } else {
                return false;
            }
        }
    }
    if(stack.size() > 0){
        return false;
    } else {
        return true;
    }
}

1.2 表达式求值

      算术表达式由括号、运算符和操作数组成，表达式求值的关键在于如何解析字符串，并按照正确的顺序完成运算。表达式有中缀表达式，不仅要考虑运算符优先级，还要考虑括号，后缀表达式已经考虑了优先级，只有操作数和运算符，在此提供两种方案解决表达式求值。

      首先定义运算符优先级，运算符只存在两个位置，栈内和栈外，优先级也分为栈内优先级（in stack priority）和栈外优先级（in comming priority），栈的特性是后进先出，栈外的运算符优先级大，则入栈它迫切先计算，对于相同级别的运算符，栈内的优先级大于栈外的优先级，则出栈。据此设计运算符优先级表：（用isp，icp分别表示栈内和栈外优先级，#号表示字符串结束）

表1 运算符优先级表

操作符	#	(	+,-	*,/	)
isp	0	1	3	5	6
icp	0	6	2	4	1

      在Java中使用两个HashMap存储栈内和栈外运算符优先级，代码如下：

static ArrayStack<String> ops = new ArrayStack<String>(10); // 运算符栈
static ArrayStack<Double> vals = new ArrayStack<Double>(20); // 操作数栈

static String opstr = "(+-*/)"; // 涉及到的运算符

static Map<String, Integer> isp = new HashMap<String, Integer>(); // 栈内优先级     
static Map<String, Integer> icp = new HashMap<String, Integer>(); // 栈外优先级
static{
    isp.put("#", 0);isp.put("(", 1); isp.put("+", 3); isp.put("-", 3); isp.put("*", 5); isp.put("/", 5); isp.put(")", 6);
    icp.put("#", 0);icp.put("(", 6); icp.put("+", 2); icp.put("-", 2); icp.put("*", 4); icp.put("/", 4); icp.put(")", 1);
}

1.2.1 直接使用中缀表达式求值

   算法描述：

   （1）初始化两个栈，操作数栈和运算符栈，顺序读取字符串

   （2）如果是操作数直接入操作数栈；

   （3）如果是运算符，如果当前运算符优先级大于运算符栈顶优先级，则直接入运算符栈，如果小于则循环弹出一个操作符，两个操作数计算，并将结果压入操作数 栈，直到找到运算符优先级比它小的，最后如果当前运算符是右括号，则弹出一个运算符（弹出的是左括号），否则入运算符栈；

   （4）如果字符为#说明已经到表达式末尾，则循环弹出操作符栈中的运算符及操作数计算，直到运算符栈为空，最后操作数栈中的元素即为结果。

/**
 * 中缀表达式计算
 */
public static double infix(String expr){
    ops.push("#");
    char[] chs = expr.trim().toCharArray();
    for(char ch : chs) {
        String op = String.valueOf(ch);
        // 如果是# 表示表达式结尾，把栈中的运算符全部弹出
        if("#".equals(op)){
            while(ops.size() > 0 && !"#".equals(ops.peek())){
                vals.push(calculate(vals.pop(), vals.pop(), ops.pop().charAt(0)));
            }
        } else if(!opstr.contains(op)){// 如果是操作数，直接输出
            vals.push(Double.valueOf(op));
        } else { // 运算符
            // 当前运算符大于栈顶运算符优先级，则直接入操作符栈
            if(icp.get(op) > isp.get(ops.peek())){
                ops.push(op);
            } else {
                // 如果小于，循环出栈找到比它优先级小的，弹出一个操作符，两个操作数，计算结果置入操作数栈
                // 如果是 右括号） 即是匹配栈内的左括号），最后弹出），（不入栈
                // 如果不是右括号，最后把这个运算符压入运算符栈
                while(icp.get(op) < isp.get(ops.peek())){
                    vals.push(calculate(vals.pop(), vals.pop(), ops.pop().charAt(0))); 
                }
                
                if(!")".equals(op)){
                    ops.push(op);
                } else {
                    ops.pop(); //弹出  ( 左括号
                }
            }
        }
    }
    return vals.pop();
}

1.2.2 使用后缀表达式求值

      后缀表达式已经包含了操作数以及运算符优先级，计算比较方便，遇操作数直接入栈，遇运算符弹出两个操作数计算后再入栈，如此循环，最后操作数栈内即为结果。关键在于如何把中缀表达式转为后缀表达式。

   中缀表达式转后缀表达式，算法描述：

   （1）初始化一个运算符栈，顺序读取表达式字符串

   （2）如果字符是操作数直接输出

   （3）如果字符是运算符，如果当前运算符优先级大于运算符栈顶优先级，则直接入运算符栈，如果小于则循环弹出一个操作符，直到找到运算符优先级比它小的，最 后如果当前运算符是右括号，则弹出一个运算符（弹出的是左括号），否则入运算符栈；

   （4）若字符为# 表示已经到末尾，循环弹出运算符栈中的元素，直到栈空，最后的输出即为中缀表达式。

/**
 * 中缀表达式转后缀
 * @param expr
 */
public static String infix2suffix(String expr){
    ops.push("#");
    StringBuffer sb = new StringBuffer();
    char[] chs = expr.trim().toCharArray();
    for(char ch : chs){
        String op = String.valueOf(ch);
        
        // 如果是# 表示表达式结尾，把栈中的运算符全部弹出
        if("#".equals(op)){
            while(ops.size() > 0 && !"#".equals(ops.peek())){
                sb.append(ops.pop());
            }
        } else if(!opstr.contains(op)){// 如果是操作数，直接输出
            sb.append(op);
        } else { // 运算符
            // 如果当前运算符优先级大于栈顶运算符优先级，则入栈
            if(icp.get(op) > isp.get(ops.peek())) {
                ops.push(op);
                continue;
            } 
            // 如果小于，弹出一个操作符，循环出栈直到比它优先级小
            // 如果是 右括号） 即是匹配栈内的左括号），最后弹出），（不入栈
            // 如果不是右括号，最后把这个运算符压入运算符栈
            while(icp.get(op) < isp.get(ops.peek())){
                sb.append(ops.pop());
            }
            
            if(!")".equals(op)){
                ops.push(op);
            } else {
                ops.pop(); //弹出  ( 左括号
            }
        }
    }
    return sb.toString();
}

1.2.3 递归

    所谓递归，就是函数调用了自己，以斐波那契数列为例，其定义为:

这是一个典型的递归例子，Java程序实现如下：

public static int Fib(int n){
    if(n == 0){
        return 0;
    } else if(n == 1){
        return 1;
    } else {
        return Fib(n-1) + Fib(n-2);
    }
}

   递归的效率不高，由于其中重复包含很多重复的计算。每个线程执行时，都有各自的栈，我们在debug时可以看到，在递归调用时，递归期间的数据都是保存在这个栈中，系统帮我们维护这个栈。

   通常情况下将递归程序转非递归程序，使用自定义栈模拟递归过程，几乎适用于所有递归，站在系统的角度，栈能解决所有问题。但是具体问题，也有其他方法转为非递归，如斐波那契数列可使用直接迭代计算出结果。

/**
 * 非递归实现，不借助栈，直接迭代
 * @return
 */
public static int NotRecur(int n){
    if(n == 0){
        return 0;
    } else if(n == 1){
        return 1;
    } else {
        int n0 = 0,
            n1 = 1; // n 为0，1时的初值
        while(n >= 2){
            int tmp = n1 + n0;
            n0 = n1;
            n1 = tmp;
            n--;
        }
        return n1;
    }
}

后续有些算法，如二叉树的遍历，会分为递归实现和非递归实现。

2．队列常见应用

2.1 层次遍历

在信息处理时，有一类问题需要逐层或逐行遍历，比如二叉树的层次遍历，图的广度优先搜索等。

2.2 缓冲区

缓冲区，是为了匹配速度，主要解决主机和外设速度不匹配，解决多用户引起资源竞争问题。