Vérification du support équilibré dans l'expression donnée à l'aide de la pile

Vous pouvez utiliser une seule pile
Une fois avoir un support ouvert, poussez-le dans la pile
Une fois avoir un support proche, vérifiez si le haut de la pile est le correspondant. de
Je ne connais pas Java, donc je vais vous donner un exemple de python xxx

une solution simplifiée en utilisant une pile xxx

Il y avait deux problèmes dans votre code

1. vérifier si (stack.peek (). Equals (Stack1.Eek (Pek ())) code> n'est pas correct, ces deux piles ont des crochets différents, par exemple '[' et ']', et ces deux caractères que vous ne pouvez pas comparer avec égale code> comme implique '[' non égal à ']'. Li> ol>

   Vous devez donc introduire plus de chèques intelligents, je peux vous suggérer d'écrire une fonction comme p> xxx pré>

   pour comparer des paires de parenthèses et le changement d'un chèque dans: p> xxx pré>

   2. Le problème suivant est manquant else code> instruction pour le si code> mentionné ci-dessus. Donc, si les crochets ne sont pas identiques, alors il suffit de revenir false code>, sinon votre programme sera renvoyé true code> après la boucle li> OL>

      import java.util.Stack;
      
      public class Solution {
      
          public static boolean checkBalanced(String exp) {
              Stack<Character> stack = new Stack<>();
              Stack<Character> stack1 = new Stack<>();
      
              int l = exp.length();
      
              //inserting the open bracket from back into the stack
              for (int i = 0; i < l; i++) {
                  if (exp.charAt(i) == '[' || exp.charAt(i) == '{' || exp.charAt(i) == '(') {
                      stack.push(exp.charAt(i));
                  }
              }
      
              //inserting the close bracket from back into the stack
              for (int i = l - 1; i >= 0; i--) {
                  if (exp.charAt(i) == ']' || exp.charAt(i) == '}' || exp.charAt(i) == ')') {
                      stack1.push(exp.charAt(i));
                  }
              }
      
              int s1 = stack.size();
              int s2 = stack1.size();
      
              //checking the size of stack that whether they are equal or not
              //if sizes are not equal then bracket is not balanced.
              if (s1 == s2) {
                  int s = stack.size();
                  for (int i = 0; i < s; i++) {
                      //checking the brackets that whether they are equal or not
                      if (bracketsMatch(stack.peek(), stack1.peek())) {
                          stack.pop();
                          stack1.pop();
                      } else {
                          return false;
                      }
                  }
                  return true;
      
              } else {
                  return false;
              }
          }
      
          public static boolean bracketsMatch(Character openBracket, Character closeBracket) {
              return (openBracket == '[' && closeBracket == ']')
                      || (openBracket == '{' && closeBracket == '}')
                      || (openBracket == '(' && closeBracket == ')');
          }
      
          public static void main(String[] args) {
              System.out.println("correct = " + checkBalanced("( exp = { a + [ b - c ] } )"));
              System.out.println("incorrect = " + checkBalanced("( exp = { a + [ b - c } ] )"));
          }
      
      }
      

Essayez ceci. XXX

problème : leur est une erreur logique votre pile s1 = ('{', '[') et s2 = ('}', ']') Donc, lorsque vous sautez les deux correspondre.

solution : vous avez la vérification S2 à partir du bas au lieu de haut (vous pouvez utiliser la file d'attente) ou que vous ne pouvez utiliser que la première pile S1 et lorsque vous avez rencontré le support de fermeture de la fermeture de la touche de fermeture et de votre contrôle. sont jumelés ou non.

P.S: Je viens de mentionner une erreur logique