栈和队列的应用

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了栈和队列的应用相关的知识,希望对你有一定的参考价值。

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 缓冲区

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

 

以上是关于栈和队列的应用的主要内容,如果未能解决你的问题,请参考以下文章

数据结构-王道2017-第3章 栈和队列-栈和队列的应用

博客作业03--栈和队列

数据结构(C语言) 栈和队列

《Java数据结构和算法》- 栈和队列

算法:栈和队列

用O的时间复杂度,找到栈和队列中的最小(大)值