使用 栈 实现括号匹配

使用 栈 实现括号匹配

Table of Contents

使用 栈数据结构 实现括号匹配的功能

rust 实现

  • 将所有符号依次存储到Vec
  • 使用 balance 判断是否平衡
  • ‘(’ 入栈 否则 出栈
  • Stack.is_empty && balance 匹配成功
// par_check.rs
fn par_checker(par:&str) -> bool {

    let mut char_list = Vec::new();
    for c in char_list {
        char_list.push(c)
    }

    let mut index = 0;
    let mut balance = true;
    let mut stack = Stack::new();
    while index < char_list.len() && balance {
        let c = char_list[index];

        if '(' == c {
            stack.push(c);
        } else {

            if stack.is_empty() {
                balance = false;
            } else {
                let _r = stack.pop();
            }
        }
        index += 1;
    }

    balance && stack.is_empty();
}

当前程序有弊端就是只能适配小括号,那如何处理三种括号呢?是有一个匹配函数

fn par_match(open: char, close: char) -> bool {
    let opens = "([{";
    let closes = ")]}";
    opens.find(open) == closes.find(close);
}

fn par_checker(par:&str) -> bool {
...
 while index < char_list.len() && balance {
        let c = char_list[index];

        if '(' == c || '[' == c || '{' == c {
            stack.push(c);
        } else {

            if stack.is_empty() {
                balance = false;
            } else {
                let top = stack.pop().unwrap();
                if !par_match(top, c) {
                    balance == false
                }
            }
        }
        index += 1;
    }

...
}

那如果 (a+b)(b+c)==func(x) 中间有其他字符 上面的程序就不太适合 需要添加过滤掉其他字符


while index < char_list.len() && balance {
        let c = char_list[index];

        if '(' == c || '[' == c || '{' == c {
            stack.push(c);
        }

         if ')' == c || ']' == c || '}' == c {

            if stack.is_empty() {
                balance = false;
            } else {
                let top = stack.pop().unwrap();
                if !par_match(top, c) {
                    balance == false
                }
            }
        }
        index += 1;
    }
Tags :

Related Posts

工厂方法模式

工厂方法模式

工厂方法模式 是一种创建型设计模式,在父类中提供一个创建对象方法,允许子类 决定实例化对象的类型 动态分派 动态分派和运行时有关,也就是 运行时多态 ,比如java中的 方法重写 具体创建类型由子类在运行时决定 延迟绑定 扩展性强: 秩序添加新的子类工厂 解偶:依赖抽象工厂和抽象产品,与具体实现解偶 运行时决策:通过多态机制,实际调用的工厂方法在运行时确定 静态分派 静态分派则是在编译时确定,比如 方法重载

Read More
Rust TDD 错误处理

Rust TDD 错误处理

rust zuowei sdlfjskafjlsjfksjflsjfksjf TODO Rust cli crate cli crate use clap

Read More
Rust:智能指针Box<T>

Rust:智能指针Box<T>

BOX<T> 是一个用于在堆上分配内存的智能指针,提供对堆内存的所有权管理。 核心概念 堆分配 Box<T> 将数据存储在堆 Heap 而非栈 Stack 上,栈上仅存储指向堆数据的指针

Read More