精华内容
下载资源
问答
  • 给定一个只包含字符’(’,’)’,’{’,’}’,’[‘和’]'的字符串判断输入字符串是否有效 思路:因为括号都是成对存在的,首先想到使用map,字符分为两类:键和值,其次要用到栈。判断新加入的字符是键还是值...

    题目:
    给定一个只包含字符’(’,’)’,’{’,’}’,’[‘和’]'的字符串,判断输入字符串是否有效
    思路:因为括号都是成对存在的,首先想到使用map,字符分为两类:键和值,其次要用到栈。判断新加入的字符是键还是值,如果是值就压入栈,如果是键就判断是否和栈顶的字符成对。
    1,建立一个Map,用来存放存放成对的括号;
    2,建立一个栈Stack,存放字符。当取出一个字符时,判断栈中是否已经有该字符所对应的map值:
    ①如无,加入栈中;
    ①若有,判断从栈顶弹出一个字符与该字符(键)对应的map值是否相等,相等则取下一个字符,否则return结束

    import java.util.*;
    
    public class Main {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            Main m = new Main();
            LinkedList <Boolean> l = new LinkedList<>();
                while (scanner.hasNext()){
                    String input = scanner.next();
                    l.add(m.isValid(input));
                    System.out.println(l.poll());
               }
        }
        public boolean isValid(String str){
            Stack <Character> stack = new Stack<>();
            Map< Character,Character> map = new HashMap<>();
            char []chars = str.toCharArray();
            map.put(')','(');
            map.put('}','{');
            map.put(']','[');
            for (int i = 0; i < str.length(); i++) {
                if(!map.containsKey(chars[i])){
                    stack.push(chars[i]);
                }else {
                    if(stack.empty() || map.get(chars[i]) != stack.pop()){
                        return false;
                    }
                }
            }
            return stack.empty();
        }
    }
    
    
    展开全文
  • 判断字符串括号是否成对存在 比如: ()()(()) OK ()[]{}{([])} OK ((())] NO 思路:遇到左括号入栈,遇到右括号,将左括号出栈(对应的右括号要存在) import java.util.HashMap; import java.util.Map; ...

    判断字符串中括号是否成对存在

    比如:

    ()()(())  OK

    ()[]{}{([])}  OK

    ((())]  NO

    思路:遇到左括号入栈,遇到右括号,将左括号出栈(对应的右括号要存在)

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Stack;
    
    public class BracketMatching {
        // pair以右括号为key, 左括号为值
        private Map<Character, Character> pair = null;
    
        public  BracketMatching()
        {
            pair = new HashMap<Character, Character>();
            pair.put(')', '(');
            pair.put('}', '{');
            pair.put(']', '[');
        }
    
        public boolean isMatch(String s)
        {
            Stack<Character> sc = new Stack<Character>();
            for (int i = 0; i < s.length(); i++)
            {
                Character ch = s.charAt(i);
                if (pair.containsValue(ch))// 如果是左括号,放入栈中
                {
                    sc.push(ch);
                } else if (pair.containsKey(ch)) // 如果是右括号
                {
                    if (sc.empty()) // 栈为空,栈头没有字符与右括号匹配
                    {
                        return false;
                    }
                    // 栈不为空,栈头字符与右括号匹配
                    if (sc.peek() == pair.get(ch))
                    {
                        sc.pop();
                    } else //网上许多列子没有这里的else代码块,导致({}[]]])会被判断为true
                    { // 栈不为空,栈头字符不与右括号匹配
                        return false;
                    }
                }
    
            }
    
            return sc.empty() ? true : false;
        }
    
        public static void main(String[] args)
        {
            BracketMatching judger = new BracketMatching();
            System.out.println(judger.isMatch("(***)-[{-------}]")); //true
            System.out.println(judger.isMatch("(2+4)*a[5]")); //true
            System.out.println(judger.isMatch("({}[]]])")); //false
            System.out.println(judger.isMatch("())))")); //false
            System.out.println(judger.isMatch("((()")); //false
            System.out.println(judger.isMatch("(){[[]]}")); //true
        }
    
    
    }

     

    转载于:https://www.cnblogs.com/duange/p/8832888.html

    展开全文
  • 给定一个字符串里面可能包含“()”、“{}”、“[]”三种括号,请使用JavaScript实现一个函数,检查字符串括号是否成对出现。 思路:栈原理,先进先出 实现:使用switch case进行判断 function isValid(s) { ...

    给定一个字符串里面可能包含“()”、“{}”、“[]”三种括号,请使用JavaScript实现一个函数,检查字符串的括号是否成对出现。

    思路:栈原理,先进后出
    实现:使用switch case进行判断

    
    function isValid(s) {
      let a = [];//存储左括号出现的地方
      let len = s.length;
      let k = 0;
      // flag为0时为不匹配
      let flag = 1;
      for (let i = 0; i < len && flag; i++) {
      //判断字符串的首尾可直接判断是否匹配
      if (s[0] == ')' || s[0] == '}' || s[0] == ']' || s[len - 1] == '(' || s[len - 1] == '{' || 		 s[len - 1] == '[') {
          return false
        }
        switch (s[i]) {
          case '(':
            a[k] = i;
            k++;
            break;
          case ')':
            var j = a[k - 1];
            // 如果匹配到右括号就把数组清空后续相同
            if (s[j] === '(') {
              a[k] = 0;
              k--;
            } else {
              flag = 0;
            }
            break;
          case '{':
            a[k] = i;
            k++;
            break;
          case '}':
            var j = a[k - 1];
            if (s[j] === '{') {
              a[k] = 0;
              k--;
            } else {
              flag = 0;
            }
            break;
          case '[':
            a[k] = i;
            k++;
            break;
          case ']':
            var j = a[k - 1];
            if (s[j] === '[') {
              a[k] = 0;
              k--;
            } else {
              flag = 0;
            }
            break;
        }
      }
      // 如果数组里面有东西则不匹配
      if (k !== 0) {
        flag = 0;
      }
      if (flag === 0) {
        return false;
      } else {
        return true;
      }
    }
    
    var ss = '(a[b(c)d]e{f}g)';
    let ss1 = '(a[b(cd)e{f}g))';
    console.log(isValid(ss));//true
    console.log(isValid(ss1));//false
    
    展开全文
  • 判断()是否成对; 运用栈的“后进先出“ 的特点,定义一个空数组,作为栈; for循环遍历字符串,当遇到“(”的时候就把“(”添加到空数组最顶端,push方法,记录发现一个左括号; 当遇到“)”就把数组中最...

    一、思路

    1. 要判断()是否成对;
    2. 运用栈的“后进先出“ 的特点,定义一个空数组,作为栈;
    3. for循环遍历字符串,当遇到“(”的时候就把“(”添加到空数组最顶端,push方法,记录发现一个左括号;
    4. 当遇到“)”就把数组中最顶端的元素弹出来,pop方法,抵消一个左括号。注意如果此时数组是空的,但是遇到“)”说明没有“(”缺少成对的“)”,则返回false;
    5. 不是括号的字符就不用考虑,让for循环继续执行,continue。
    6. 遍历完成后,判断栈是否为空。如果为空则表明左右括号数量刚好抵消,则返回true,否则返回false。

     

    二、代码

    function is_leagl_brackets(string) {
      var array = [];
      for (var i = 0; i < string.length; i++) {
        var item = string[i];
        if (item === "(") {
          array.push("(");
        } else if (item === ")") {
          if (array.length === 0) {
            return false;
          } else {
            array.pop();
          }
        } else {
          continue;
        }
      };
      return array.length === 0;
    };
    
    
    console.log("(asd):", is_leagl_brackets("(asd)"));
    console.log("asd(asd(adsfsdf(asdf())))):", is_leagl_brackets("asd(asd(adsfsdf(asdf()))))"));

     

     

    三、查看结果

     

      

    转载于:https://www.cnblogs.com/hcxwd/p/10420835.html

    展开全文
  • 练习题目利用栈先将后出的特性,判断字符串中的数字表达式括号是否成对匹配,如果没有给出错误位置信息提示。代码实现代码思路很简单,如果是左括号将左括号 就入栈,遇到右括号 栈中的左括号出栈。如果该出栈的时候...
  • 有一个字符串,如'sdfsd{sss}{{sd}}',请判断字符串中的'{}'是否合法,'{}','{{}}'都视为合法,'}{','{{}'...为不合法。 一开始我是硬写,没什么思路,后来偶然看到一篇文章,是关于浏览器解析dom标签的原理,从中受...
  • 判断字符串中的括号是否成对出现

    千次阅读 2016-10-07 15:18:10
    public static void main(String[] args) { String str = "淮安市设备招标(第一(标段))工程建设(招标)公告";  CheckStr checkstr=new ... System.out.println("括号是不匹配的");  }  } 
  • * 利用栈的思想判断字符串表达式中括号是否成对。 栈先进后出 * * @param expression * @return */ public static boolean valid(String expression) { // 定义一个栈数据结构 ArrayStack stack = ...
  • 字符串括号成对匹配

    2019-06-16 10:03:10
    其实,要知道字符串括号成对匹配,这个问题也是在面试中常见的算法问题,获取有效的思路很是重要,当然我们可以借助Stack的特性处理! 思路: 使用栈 遇到左括号入栈 遇到又括号出栈,如果匹配则最后栈为空,不...
  • 1、将字符串的每个字符进行遍历 2、如果发现是左括号,那么将该字符压入到栈中 3、如果是右括号,先去存储好的栈顶找到相应的值 4、若栈为空返回false,若匹配,pop该左括号,若不匹配也返回false 5、最后看存储栈中...
  • 判断字符串中的括号是否匹配

    千次阅读 2019-08-01 19:57:20
    题目:给你一个字符串,判断字符串中的括号是否匹配,意思就是一个左括号要对应一个右括号,即'('和')'必须成对出现。那不就是判断字符串里面的'('和')'数量是不是相等吗,这个简单呀,用stl算法里面的count()...
  • 从键盘读入一个字符串,其中只含有() {} [ ] ,判断字符串中的每种括号是否成对出现。 提示:可借助栈来实现,括号必须配对出现,如()[ ]{},这是匹配的括号,如([{])},这是不匹配的括号(中间无空格)。 ...
  • 需求:判断字符串中的括号使用是否合理 思路:由于,括号是穿插于字符之间的,字符于字符的组合形式众多,无法直接判断出括号的使用情况;换个思路,可以从括号本身使用的方法入手:1. 成对出现 2.形式固定 代码如下...
  • 判断一个字符串括号是否匹配

    万次阅读 2016-12-03 09:02:26
    从键盘读入一个字符串,其中只含有() {} [ ] ,判断字符串中的每种括号是否成对出现。 提示:可借助栈来实现,括号必须配对出现,如()[ ]{},这是匹配的括号,如([{])},这是不匹配的括号(中间无空格)。 输入...
  • 判断一个字符串 是否是 "等括号"字符串括号的含义 1).必须成对出现 有开始有结束 “()” “[]” 2).允许括号嵌套 “([])” “[{}([])]” 3).但是不允许单独嵌套 “{(})” “({[}])” 4).字符串中只有一共四种...
  • C#编写程序判断给定的表达式字符串中的括号是否正确匹配(成对出现) 例如: 正确的字符串:{[{}{}]}[()],或{{}{}},或者[]{}() 错误的字符串:{()}[),或{(}),或({[{ using System; using System.Collections.Generic; ...
  • 例如: 正确的字符串:{[{}{}]}{()},或{{}{}},或者[]{}{} 错误的字符串:{()}[),或{(}),或者({[{ ...判断是否正确匹配(成对出现) static void Main(string[] args) { String exp = "{()}[{}]"; ...
  • 从键盘读入一个字符串,其中只含有() {} [ ] ,判断字符串中的每种括号是否成对出现。 提示:可借助栈来实现,括号必须配对出现,如()[ ]{},这是匹配的括号,如([{])},这是不匹配的括号(中间无空格)。 输入...
  • 判断括号是否成对

    2019-10-05 09:31:06
    就是在一个只有括号的字符串里的括号是否合法。 所谓合法就是成对,比如 "{}[](){([])}" 但是这样就是不对的 “[((((])” 以及包含的顺序不对 “([)]” 都判为非法。 bool isValid(string s) { unordered_map&...
  • 给定一个只包括 '(',')','{','}','[',']'的字符串,判断字符串是否有效。 有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 ...遇到左括号就入栈, 遇到右括号就出栈 , 看...
  • 需求:给定一个由括号([{)]}其中之一或多个组成的字符串判断是否符合左右括号成对标准,不同括号可任意嵌套 只有单个左或右括号 均不符合)(、}{、][ 不符合(){}[] 符合({[]}) 符合({}[)] 符合()() 符合 左括号位置...
  • 判断一个字符串中的括号是否成对出现该题的核心思路在于使用栈。 该方法虽然不是最优解 但是思路还是比较清晰的 /** * @author rale * Given a string containing just the characters '(', ')', '{', '}', '[' ...
  • 需求: 判断一个字符串中的括号是否成对,是否合法? const str1 = '((3223)2)2(2)' const str2 = ')22(12)sf1(sdfs' 思路: 创建一个后进先出的栈 遍历字符串 如果元素是( 压入栈中 如果是 ),就要判断栈是否...
  • 括号字符串判断

    2019-07-23 20:23:22
    判断一个字符串 是否是 "等括号"字符串括号的含义 1).必须成对出现 有开始有结束 “()” “[]” 2).允许括号嵌套 “([])” “[{}([])]” 3).但是不允许单独嵌套 “{(})” “({[}])” 4).字符串中只有一共四种括号...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 203
精华内容 81
关键字:

判断字符串括号是否成对