栈练习之Example001-判断一个算术表达式中的括号是否正确配对

最新推荐文章于 2023-04-29 11:49:30 发布
最新推荐文章于 2023-04-29 11:49:30 发布
阅读量8k 收藏 107
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 栈 顺序栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/124357767
版权

Example001

题目

C 语言中算术表达式中的括号只有小括号。编写算法，判断一个表达式中的括号是否正确配对，表达式已经存入字符数组 exp[] 中，表达式的字符个数为 n。

分析

例如算术表达式：3*(a++)+c*(b+(2+d))+d*3。其实表达式中括号匹配分为如下三种情况：

  • 完全匹配，如 ((())) 中左括号 ( 和右括号 ) 的个数是完全相等的。如果将左括号入栈，右括号与栈顶元素进行比较，那么最后栈为空，表示匹配成功。
  • 不完全匹配，如 (())) 中左括号 ( 和右括号 ) 的个数不完全相等，并且右括号的个数大于左括号的个数。如果将左括号入栈，右括号与栈顶元素进行比较，那么一定会出现空栈与右括号比较的情况，表示匹配失败。
  • 不完全匹配，如 ((()) 中左括号 ( 和右括号 ) 的个数不完全相等，并且左括号的个数大于右括号的个数。如果将左括号入栈，右括号与栈顶元素进行比较，当遍历完字符数组后，那么栈中一定还剩余左括号，表示匹配失败。

其实看到上面的三种情况，就明白了，我们只需要处理小括号字符，不关注其他非小括号字符，并且将左括号字符加入到栈中，将右括号字符与左括号字符进行配对比较。

下面的代码中使用的是标准的顺序栈，而非一个简单的数组，书中采用的就是利用简单的数组来实现栈的功能。具体可参考：考研数据结构之栈（2.3）——练习题之判断表达式中的括号是否正确配对（C表示）

图解

以 3*(a++)+c*(b+(2+d))+d*3 为例，步骤如下：

  • （0）空顺序栈如下：

在这里插入图片描述

  • （1）第一个扫描到的字符是 3，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （2）接着扫描到的字符是 *，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （3）接着扫描到的字符是 (，是左圆括号，将其入栈。此时顺序栈如图所示：

在这里插入图片描述

  • （4）接着扫描到的字符是 a，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （5）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （6）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （7）接着扫描到的字符是 )，是右圆括号，判断是否栈空，如果栈空则直接返回 0 表示不匹配；如果栈非空则将栈顶元素（即左圆括号）出栈，即 ( 与 ) 相互配对。此时顺序栈如图所示：

在这里插入图片描述

  • （8）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （9）接着扫描到的字符是 c，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （10）接着扫描到的字符是 *，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （11）接着扫描到的字符是 (，是左圆括号，将其入栈。此时顺序栈如图所示：

在这里插入图片描述

  • （12）接着扫描到的字符是 b，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （13）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （14）接着扫描到的字符是 (，是左圆括号，将其入栈。此时顺序栈如图所示：

在这里插入图片描述

  • （15）接着扫描到的字符是 2，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （16）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （16）接着扫描到的字符是 d，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （17）接着扫描到的字符是 )，是右圆括号，判断是否栈空，如果栈空则直接返回 0 表示不匹配；如果栈非空则将栈顶元素（即左圆括号）出栈，即 ( 与 ) 相互配对。此时顺序栈如图所示：

在这里插入图片描述

  • （18）接着扫描到的字符是 )，是右圆括号，判断是否栈空，如果栈空则直接返回 0 表示不匹配；如果栈非空则将栈顶元素（即左圆括号）出栈，即 ( 与 ) 相互配对。此时顺序栈如图所示：

在这里插入图片描述

  • （19）接着扫描到的字符是 +，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （20）接着扫描到的字符是 d，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （21）接着扫描到的字符是 *，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （22）接着扫描到的字符是 3，既不是左圆括号，也不是右圆括号，所以跳过，继续判断下一个字符。
  • （23）扫描完成，判断顺序栈是否为空，如果为空则表示所有圆括号配对成功；如果不为空则表示左圆括号多于右圆括号，也配对失败。

C实现

核心代码：

/**
 * 判断字符序列中的小括号是否匹配
 * @param exp 包括小括号的字符序列
 * @param n 数组长度
 * @return 如果字符序列中的小括号完全匹配则返回 1，否则返回 0 表示匹配失败
 */
int isMatch(char exp[], int n) {
    // 声明一个顺序栈并初始化，用来存储小括号
    SeqStack stack;
    init(&stack);

    // 局部变量，无任何实际意义，仅用于填充 pop 函数的第二个参数
    char top;
    // 扫描字符数组，循环遍历每个字符
    for (int i = 0; i < n; i++) {
        // 如果是小括号中的左括号（即 '('），将其存储到顺序栈中
        if (exp[i] == '(') {
            push(&stack, exp[i]);
        }
        // 如果是小括号中的右括号（即 ')'），那么将栈顶元素出栈
        else if (exp[i] == ')') {
            // 注意，有可能栈空，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
            if (isEmpty(stack)) {
                // 所以直接返回 0 表示不配对
                return 0;
            } else {
                // 如果栈不为空，才将顺序栈栈顶元素出栈，表示一对括号匹配成功
                pop(&stack, &top);
            }
        }
    }
    // 如果是空栈，表示所有括号正确匹配；如果不是空栈，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
    if (isEmpty(stack)) {
        return 1;
    } else {
        return 0;
    }
}

完整代码：

#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct {
    /**
     * 数据域，数组，用来存储栈中元素
     */
    char data[MAXSIZE];
    /**
     * 指针域，表示栈顶指针，实际上就是数组下标
     */
    int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack) {
    // 设定让栈顶指针指向 -1 表示为栈空
    stack->top = -1;
}

/**
 * 判断顺序栈是否为空
 * @param stack 顺序栈
 * @return 如果顺序栈为空则返回 1，否则返回 0
 */
int isEmpty(SeqStack stack) {
    // 只需要判断栈顶指针是否等于 -1 即可，如果是空栈则返回 1，不是空栈则返回 0
    if (stack.top == -1) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, char ele) {
    // 1.参数校验，如果栈满则不能入栈元素
    if (stack->top == MAXSIZE - 1) {
        // 如果栈满，则返回 0，表示不能入栈
        return 0;
    }
    // 2.先将栈顶指针加一，指向新空数组位置
    stack->top++;
    // 3.将新元素值填充到新位置中
    stack->data[stack->top] = ele;
    return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, char *ele) {
    // 1.参数校验，栈空不能出栈
    if (stack->top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.用 ele 来保存顺序栈栈顶元素
    *ele = stack->data[stack->top];
    // 3.然后栈顶指针减一，表示出栈一个元素
    stack->top--;
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, char *ele) {
    // 1.参数校验，如果栈空则不能出栈
    if (stack.top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.保存栈顶元素返回
    *ele = stack.data[stack.top];
    return 1;
}

/**
 * 判断字符序列中的小括号是否匹配
 * @param exp 包括小括号的字符序列
 * @param n 数组长度
 * @return 如果字符序列中的小括号完全匹配则返回 1，否则返回 0 表示匹配失败
 */
int isMatch(char exp[], int n) {
    // 声明一个顺序栈并初始化，用来存储小括号
    SeqStack stack;
    init(&stack);

    // 局部变量，无任何实际意义，仅用于填充 pop 函数的第二个参数
    char top;
    // 扫描字符数组，循环遍历每个字符
    for (int i = 0; i < n; i++) {
        // 如果是小括号中的左括号（即 '('），将其存储到顺序栈中
        if (exp[i] == '(') {
            push(&stack, exp[i]);
        }
        // 如果是小括号中的右括号（即 ')'），那么将栈顶元素出栈
        else if (exp[i] == ')') {
            // 注意，有可能栈空，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
            if (isEmpty(stack)) {
                // 所以直接返回 0 表示不配对
                return 0;
            } else {
                // 如果栈不为空，才将顺序栈栈顶元素出栈，表示一对括号匹配成功
                pop(&stack, &top);
            }
        }
    }
    // 如果是空栈，表示所有括号正确匹配；如果不是空栈，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
    if (isEmpty(stack)) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    char arr[] = "3*(a++)+c*(b+(2+d))+d*3";
    int n = 23;

    // 调用函数判断字符序列中的小括号是否配对
    int result;
    result = isMatch(arr, n);
    printf("%s 中小括号是否匹配：%d", arr, result);
}

执行结果：

3*(a++)+c*(b+(2+d))+d*3 中小括号是否匹配：1

Java实现

核心代码：

    /**
     * 判断指定字符序列中的括号是否配对成功
     *
     * @param arr 字符序列
     * @return 如果配对成功则返回 1，否则返回 0 表示失败
     * @throws Exception 如果栈满再入栈则抛出异常
     */
    public static int isMatch(char[] exp) throws Exception {
        // 声明一个顺序栈并初始化，用来存储小括号
        SeqStack stack = new SeqStack();
        stack.init();

        // 变量，记录数组长度
        int n = exp.length;
        // 扫描字符数组，循环遍历每个字符
        for (int i = 0; i < n; i++) {
            // 如果是小括号中的左括号（即 '('），将其存储到顺序栈中
            if (exp[i] == '(') {
                stack.push(exp[i]);
            }
            // 如果是小括号中的右括号（即 ')'），那么将栈顶元素出栈
            else if (exp[i] == ')') {
                // 注意，有可能栈空，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
                if (stack.isEmpty()) {
                    // 所以直接返回 0 表示不配对
                    return 0;
                } else {
                    // 如果栈不为空，才将顺序栈栈顶元素出栈，表示一对括号匹配成功
                    stack.pop();
                }
            }
        }
        // 如果是空栈，表示所有括号正确匹配；如果不是空栈，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
        if (stack.isEmpty()) {
            return 1;
        } else {
            return 0;
        }
    }

完整代码：

public class Test {
    public static void main(String[] args) throws Exception {
        String str = "3*(a++)+c*(b+(2+d))+d*3";

        int result;
        result = isMatch(str.toCharArray());
        System.out.println(str + "中小括号是否配对：" + result);
    }

    /**
     * 判断指定字符序列中的括号是否配对成功
     *
     * @param arr 字符序列
     * @return 如果配对成功则返回 1，否则返回 0 表示失败
     * @throws Exception 如果栈满再入栈则抛出异常
     */
    public static int isMatch(char[] exp) throws Exception {
        // 声明一个顺序栈并初始化，用来存储小括号
        SeqStack stack = new SeqStack();
        stack.init();

        // 变量，记录数组长度
        int n = exp.length;
        // 扫描字符数组，循环遍历每个字符
        for (int i = 0; i < n; i++) {
            // 如果是小括号中的左括号（即 '('），将其存储到顺序栈中
            if (exp[i] == '(') {
                stack.push(exp[i]);
            }
            // 如果是小括号中的右括号（即 ')'），那么将栈顶元素出栈
            else if (exp[i] == ')') {
                // 注意，有可能栈空，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
                if (stack.isEmpty()) {
                    // 所以直接返回 0 表示不配对
                    return 0;
                } else {
                    // 如果栈不为空，才将顺序栈栈顶元素出栈，表示一对括号匹配成功
                    stack.pop();
                }
            }
        }
        // 如果是空栈，表示所有括号正确匹配；如果不是空栈，那么就是右括号至少多一个，那么表达式中的括号一定不会是配对的
        if (stack.isEmpty()) {
            return 1;
        } else {
            return 0;
        }
    }
}

SeqStack：

public class SeqStack {
    /**
     * 常量，顺序栈所能容纳的最大元素个数
     */
    private final int MAXSIZE = 100;

    /**
     * 声明一个顺序栈
     */
    private Stack stack;

    /**
     * 初始化顺序栈
     */
    public void init() {
        // 实例化栈对象
        stack = new Stack();
        // 为数据域分配空间
        stack.data = new char[MAXSIZE];
        // 将顺序栈的栈顶指针指向 -1 表示空栈
        stack.top = -1;
    }

    /**
     * 判断顺序栈是否为空
     *
     * @return 如果顺序栈为空则返回 true，否则返回 false
     */
    public boolean isEmpty() {
        // 规定了 -1 表示空栈，所以只需要判断栈顶指针是否等于 -1 即可
        return stack.top == -1;
    }

    /**
     * 将指定元素入栈
     *
     * @param ele 指定元素
     * @throws Exception 如果栈满则不能入栈，抛出此异常
     */
    public void push(char ele) throws Exception {
        // 1.参数校验，如果栈满则不能入栈，抛出异常
        if (stack.top == MAXSIZE - 1) {// 因为栈顶指针 top 存储的是数组下标，所以判断是否等于 MAXSIZE-1
            throw new Exception("栈已满，不能再插入！");
        }
        // 2.先栈顶指针加 1，因为原栈顶指针处已经存储了元素，所以加一指向新的空位置
        stack.top++;
        // 3.在新的空位置处插入新元素，即为指定下标的数组元素赋值
        stack.data[stack.top] = ele;
    }

    /**
     * 将栈顶元素出栈
     *
     * @return 栈顶元素
     * @throws Exception 如果栈空则不能出栈，抛出此异常
     */
    public char pop() throws Exception {
        // 1.参数校验，如果栈空则不能出栈，抛出异常
        if (stack.top == -1) {// 因为栈空的定义是栈顶指针为 -1，所以如果栈顶指针为 -1 那么就是空栈，就不能出栈元素
            throw new Exception("栈为空，不能出栈元素！");
        }
        // 2.记录栈顶元素，因为要将该元素返回，即要出栈的元素
        char result = stack.data[stack.top];
        // 3.栈顶指针减一，因为原栈顶元素已经出栈了，栈中元素个数减一
        stack.top--;
        return result;
    }

    /**
     * 获取栈顶元素，但不出栈
     *
     * @return 栈顶元素
     * @throws Exception 如果栈空则不能出栈，抛出此异常
     */
    public char getTop() throws Exception {
        // 1.参数校验，如果栈空则不能出栈，抛出异常
        if (stack.top == -1) {
            throw new Exception("栈为空，不能获取栈顶元素！");
        }
        // 2.直接返回栈顶元素，但不出栈
        return stack.data[stack.top];
    }

    /**
     * 顺序栈中元素个数
     *
     * @return 栈中元素个数
     */
    public int size() {
        // top 表示栈顶指针，实际上就是数组 data 的下标，所以实际元素个数就是下标加一
        // 即使是空栈 top=-1，那么最后也会返回 0 表示元素个数为零个
        return stack.top + 1;
    }

    /**
     * 打印顺序栈中所有元素，从栈顶到栈底
     */
    public void print() {
        System.out.print("[");
        for (int i = stack.top; i >= 0; i--) {
            if (i != stack.top) {
                System.out.print(", ");
            }
            System.out.print(stack.data[i]);
        }
        System.out.print("]\n");
    }

    /**
     * 清空顺序栈
     */
    public void clear() {
        // 直接将栈顶指针指向 -1 即可表示空栈，不用重置栈中已有元素的值，因为顺序栈操作只跟栈顶指针有关
        stack.top = -1;
    }
}

/**
 * 栈定义
 */
class Stack {
    /**
     * 顺序栈用来存储元素的数组
     */
    char[] data;
    /**
     * 记录顺序栈的栈顶指针，即数组下标
     */
    int top;
}

执行结果：

3*(a++)+c*(b+(2+d))+d*3中小括号是否配对：1
二木成林
关注
  • 18
    点赞
  • 踩
  • 107
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验-括号匹配的检验-链栈实现
06-30
数据结构实验-括号匹配的检验-链栈实现
正则表达式练习-附文末答案
最新发布
09-12
这些练习将帮助用户深入理解正则表达式的语法和特殊字符的含义，例如`.`代表任意字符，`\d`代表数字，`\w`代表字母或数字，`^`表示开始，`$`表示结束，`*`表示前一个元素零次或多次，`+`表示一次或多次，`?...
考研数据结构之栈（2.3）——练习题之判断表达式中的括号是否正确配对（C表示）
二木成林
05-22 6189
题目 C语言中算术表达式中的括号只有小括号。编写算法，判断一个表达式中的括号是否正确配对，表达式已经存入字符数组exp[]中，表达式的字符个数为n。 分析 本题可以用栈来解决，下面就来说说为什么要用栈来解决。 给你一个表达式，目测怎么判断括号是否匹配呢?可以这样做，从左往右看这个表达式中的括号，看到一个“(“就记住它(这里可以理解为入栈)，如果下一个括号是“)”(这里可以理解为出栈)，则划掉这两个括号，一对括号处理完毕继续往后看。如果前边所有的括号都被划掉，而下一个括号却是“)”，则括号一定不匹配，
判断表达式中的括号是否匹配（是否使用规范）（代码运行图解）
weixin_65259109的博客
01-08 980
#判断括号是否配对 #括号配对：在平常的算数运算中，括号只会成对出现，并且括号内的括号只会完整出现，从形式上将，左括号的顺序与剩下括号是对称的;左括号与右括号分别分配在一边与另一边 #例如：（{[()]}）、（[][]） #考虑到判断对称，由于栈的性质就是先进后出，意味着元素进栈之后再出栈顺序会颠倒 #那么，只要让左括号全部进栈，然后一个个出栈和右边剩下的右括号一一比对即可 具体代码如下：（SqStack中的操作请见我的主页顺序栈基本操作） 运行图解如下：
判断算术表达式中的括号是否匹配
weixin_42070473的博客
07-01 9924
问题描述：假设一个算术表达式中包含圆括号、方括号和花括号3种类型的括号，编写一个算法来判断表达式中的括号是否匹配，以字符“#”作为算术表达式的结束符。 解决问题思想：遇见左括号就进栈，遇见右括号就出栈。当括号匹配时上一次进栈和本次出栈的括号肯定配对，所以不需要循环依次出栈判断括号是否配对(此处之前没有想到，导致在出栈时还用了依次循环来判断是否配对，这样做会导致算法时间复杂度增加)；如果不配对，则...
用栈判断表达式中的括号是否匹配
热门推荐
努力提高姿势水平
04-15 1万+
栈的简单应用。
rust-onig:Oniguruma正则表达式库的Rust绑定
05-04
锈色奥尼格 用于Rust绑定，这是一个功能强大且成熟的正则表达式库，支持多种字符集和语言语法。 Oniguruma用C编写。此存储库提供了两个板条箱：提供原始Rust FFI绑定的onig-sys和提供围绕它们的安全Rust包装器的onig...
判断链表是否为回文链表leetcode-LeetCode-Exercise:只是一个自我练习的leetcode合集
07-01
判断链表是否为回文链表 leetcode leetCode-Exercise 个人 LeetCode 练习合集。 目前需要使用的数据结构 题解 Two Sum Given an array of integers, return indices of the two numbers such that they add up to a ...
java代码-编写一个程序判断字符串是否出现在另一个字符串
07-15
在Java编程中，判断一个字符串是否出现在另一个字符串中是一个常见的任务，这通常涉及到字符串操作和比较。本项目提供了一个简单的Java程序，用于实现这个功能。下面我们将深入探讨相关的知识点。 首先，我们需要...
regex-by-example:学习正则表达式，并在我学习时将其发布，然后将其用js编写
05-13
这个压缩包“regex-by-example”显然是一个关于正则表达式的学习资源，作者在学习过程中逐步积累并分享了相关知识。下面，我们将深入探讨正则表达式的基础概念、常用元字符、模式匹配、JavaScript中的应用以及如何...
利用顺序栈实现：判别表达式中括弧是否正确配对（BracketMatch函数）
TysonSir的博客
03-30 3778
/*假设一个算数表达式中包含圆括弧、方括弧和花括弧三种类型的括弧，编写一个判别表达式中 括弧是否正确配对的BracketMatch函数。*/ int BracketMatch(SElemType *str);
栈的经典用法——判断括号是否匹配
长期更新Java自学笔记
11-04 8424
#简单说明栈的特征： 本处使用顺序栈判断括号匹配，首先我们知道栈是一种只能在一段操作的线性表。其插入，删除仅能在一端进行操作，就像一个瓶子一样，不管是取东西还是放东西都只能在瓶口进行，那么最后最先进栈的元素就一定是最后出栈的元素。利用这一特性，我们就可以判断括号是否匹配了。 #主要思路如下： 我们从左到右依次扫描需要判断的字符串，遇见“（”，“{”，“[”就入栈，遇见“）”，“]”，“]”就出栈，...
判定一个算术表达式中的圆括号是否正确配对
peerless1024的博客
03-29 6463
#include<stdlib.h> #include<stdio.h>#define STACK_LIST_SIZE 100 #define STACKINCREMENT 10 #define MAXSIZE 100 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2typedef int
Python P1739 表达式括号匹配 (栈的使用)
vilililli的博客
04-29 388
作为表达式的结束符。请编写一个程序检查表达式中的左右圆括号是否匹配，若匹配，则输出。表达式长度小于 255，左圆括号少于 20 个。表达式长度小于 255，左圆括号少于 20 个。假设一个表达式有英文字母（小写）、运算符（）和左右小（圆）括号构成，以。
利用栈的相关知识检验括号是否匹配
qq_62767608的博客
12-16 3554
栈的相关特点相信大家都知道，那么我们如何利用它来检验括号是否匹配呢。 主要思路如下： 1.扫描整个表达式； 2.判断当前字符是否为括号（左右括号） ①如果不是，则继续扫描下一个字符； ②如果是，则判断当前操作符是否为左括号 若为左括号—>直接入栈。 若栈为空—> 说明此表达式右括号多于左括号。 若栈为空—> 说明此表达式右括号多于左括号。 若栈不为空—>判断当前操作符是否和栈顶操作符匹配，若不匹配—->说明左右括号不匹配，若匹配—–>则继续判断下一个操作符。 3.最
判断一个字符串中括号是否匹配
夜、醉梦红尘
11-28 5136
思路： 1. 括号匹配的四种可能性： ①左右括号配对次序不正确 ②右括号多于左括号 ③左括号多于右括号 ④左右括号匹配正确 2. 算法思想： 1.顺序扫描算数表达式（表现为一个字符串），当遇到左括号时候让该括号保存至list； 2.当扫描到右括号时，查看当前list里面是否有内容，若为空，说明格式不对，返回错误标识。如果有内容，则弹出list末尾元素； 3.字符串循环
数据结构【栈】（九）：使用栈检查括号是否匹配
码客
03-24 3897
问题描述 给一个字符串表达式，包含一个或多个括号，现要求使用栈检查该字符串表达式中的括号是否平衡。 解答思路 遍历字符串中的每个字符，如果： 1）出现左括号则进栈 2）出现右括号则首先检判断栈是否为空，如果不为空，则判断与栈顶元素是否与之匹配，如果匹配则弹出栈顶元素。 3）最后若栈空，则表明匹配成功；否则表明不匹配。 代码实现 /** * @param s 字符串表达式 * ...
栈的基本操作及如何判断一个表达式中的左右括号是否匹配
小葱的博客
04-21 1万+
我们都知道，栈（stack）具有后进先出的特点，所以在我们思考一个表达式中的左右括号是否匹配问题时，就自然会想到是不是可以利用栈的特点来判断左右括号是否匹配呢？ 主要思路如下： 1.扫描整个表达式； 2.判断当前字符是否为括号（左右括号） ①如果不是，则继续扫描下一个字符； ②如果是，则判断当前操作符是否为左括号 若为左括号—>直接入栈。
【算法】使用栈检查表达式的括号匹配
柠檬柠檬C的博客
09-27 3770
使用栈检查表达式的括号匹配 给定一个表达式字符串exp，编写一个程序来检查对和“{”，“}”，“（”，“）”，“[”，“]”的顺序是否在exp中是正确的。 例如，程序应该为exp =“[（）] {} {[（）（）]（）}”打印为true，对于exp =“[（]）”则为false。 算法步骤 其实这种字符串有一个特点，就是如果当前字符串是“右边”的括号类型，那么它的前一个必定是与之匹配的括号。 声...
设计一个算法判别一个算术表达式的圆括号是否正确配对java代码
04-17
好的，这是一个与算法有关的问题，我可以回答。可以使用栈这一数据结构来判断圆括号是否正确配对。具体的 Java 代码如下： ``` import java.util.Stack; public class ParenthesisMatcher { public static boolean isParenthesisMatched(String expression) { Stack<Character> stack = new Stack<>(); for (char c : expression.toCharArray()) { if (c == '(') { stack.push(c); } else if (c == ')') { if (stack.isEmpty()) { return false; } else { stack.pop(); } } } return stack.isEmpty(); } public static void main(String[] args) { String expression = "((2 + 3) * 5 - 6) / ((1 + 2) * 3)"; // example expression boolean isMatched = isParenthesisMatched(expression); System.out.println("Parenthesis matched? " + isMatched); } } ``` 这个代码利用了栈的特性：当遇到左括号时入栈，遇到右括号时弹出栈顶元素。如果在弹出栈顶元素之前栈已经为空，说明括号没有正确匹配，返回 false；如果最终栈为空，说明所有括号都正确匹配，返回 true。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值