Проверка скобок с использованием стека и очереди в C #

Question

У меня возникла проблема с решением Bracket Checker.
Кажется, я не могу решить проблему, если пользователь введет эту последовательность скобок, тогда моя программа должна напечатать ее неверную последовательность

Ввод:

({} [)

Вывод:

Неправильная последовательность

Мой код ниже

        Stack s = new Stack();

        Queue q = new Queue();

        bool isok = true;

        string FinalData = "0";            

        Console.WriteLine("Enter Brackets");

        string data = Console.ReadLine();

        for (int i = 0; i < data.Length; i++)
        {
            if (data.Substring(i, 1) == "{"
             || data.Substring(i, 1) == "["
             || data.Substring(i, 1) == "("
                )
            {
                s.Push(data.Substring(i, 1));
            }
            else
            {
                q.Enqueue(data.Substring(i, 1));
            }
        }
        while (s.Count > 0 && q.Count > 0)
        {
            FinalData = (String)s.Pop();
            string value = (String)q.Dequeue();
            if (FinalData == value)
            {
                isok = false;
                break;
            }                 
        }

        if (isok)
            Console.WriteLine(data + " is a Right Sequence.");
        else
            Console.WriteLine(data + " is Not a Right Sequence.");
        Console.ReadLine();
    }

Answer 1

Я дам вам несколько советов и основную идею:

• вам не нужна очередь, просто Stack<char>.
• читать входные данные для каждого символа:
  • если символ - открытая скобка, нажмите на него
  • если символ является закрытой скобкой, вытолкните стек и сравните.
  • отменить другие символы

Answer 2

boolean isCorrect;

public boolean checkBraces(String braces)
{
    Stack<Character>stack = new Stack<Character>();
    int openBCount = 0;
    int closeBCount = 0;                                                                

    for(int c = 0; c<=braces.length()-1; c++)
    {
        //check for open braces push to stack

        if(braces.charAt(c)=='{' || braces.charAt(c)=='[' ||braces.charAt(c)=='(')
        {


            stack.push(braces.charAt(c));
            openBCount++;

        }                                                                       ////check for close braces. pop the open braces
                                                                                 //compare it to the closed braces using the the 
                                                                                 //method ValidatePerBraces                                                                      
                                                                                 //therefor checking for CORRECTNEES of how the braces                                                                       //are closed
        else if(braces.charAt(c)=='}' || braces.charAt(c)==']' || braces.charAt(c)==')')
        {

            closeBCount++;
            if(!ValidatePerBraces(stack.pop(), braces.charAt(c))) 
            {
                isCorrect = false; //return false in case where they dont match
                return isCorrect;
            }

        }
                                //for braces to be complete, open and close braces
                                //should be even, if they are not even then it is 
                                //for sure wrong at least for the specification.
        if(c>=braces.length()-1)
        {

            if(openBCount != closeBCount)
            {
                isCorrect = false; 
                return isCorrect;
            }
        }

    }


    isCorrect = true; // true if they all match

    return isCorrect;
}

// returns true if validated
public boolean ValidatePerBraces(char a, char b)
{

    return a == '(' && b== ')' || a == '[' &&  b == ']' || a == '{' && b== '}' ;

}

Answer 3

static bool IsBracesValidator(string input)
{
    bool IsValidBraces = true;

    char[] chrArray = input.ToCharArray();

    List<Char> foundOpenParanthesis = new List<char>();
    List<Char> foundClosedParanthesis = new List<char>();

    char[] chrOpenParanthesis = { '{', '[', '(', '<' };
    char[] chrClosedParanthesis = { '}', ']', ')', '>' };
    for (int i = 0; i <= chrArray.Length - 1; i++)
    {
        if (chrOpenParanthesis.Contains(chrArray[i]))
        {
            foundOpenParanthesis.Add(chrArray[i]);
        }

        if (chrClosedParanthesis.Contains(chrArray[i]))
        {
            foundClosedParanthesis.Add(chrArray[i]);
        }
    }

    if (foundOpenParanthesis.Count == foundClosedParanthesis.Count)
    {
        for(int i=0;i< foundOpenParanthesis.Count;i++)
        {
            char chr = foundOpenParanthesis[i];
            switch (chr)
            {
                case '[': chr = ']'; break;
                case '<': chr = '>'; break;
                case '(': chr = ')'; break;
                case '{': chr = '}'; break;
            }

            if (!chr.Equals(foundClosedParanthesis[foundClosedParanthesis.Count - i-1]))
            {
                IsValidBraces = false;
                break;
            }
        }
    } else
    {
        IsValidBraces = false;
    }

    return IsValidBraces;
}

Answer 4

Спасибо, ребята, я решил проблему, используя стек и очередь в одно и то же время.Вот код

        Stack s = new Stack();

        Queue q = new Queue();

        bool isRight = true;

        char OpeningBracket = ' ';

        char closingBracket = ' ';

        Console.WriteLine("Enter Brackets");
        string data = Console.ReadLine();
        char[] character = data.ToCharArray();
        for (int i = 0; i < character.Length; i++)
        {
            if (character[i] == '(' || character[i] == '{' ||
                character[i] == '[')
            {
                s.Push(character[i]);
            }
            else
                q.Enqueue(character[i]);
        }

        if (s.Count == 0 || q.Count == 0)            
            isRight = false;

        while (s.Count > 0 && q.Count > 0)
        {
            OpeningBracket = (char)s.Pop();
            closingBracket = (char)q.Dequeue();
            if ((OpeningBracket == '(' && closingBracket != ')')
           ||   (OpeningBracket == '[' && closingBracket != ']')
           ||   (OpeningBracket == '{' && closingBracket != '}')
                )
            {
                isRight = false;
            }

        }

        if (isRight)
            Console.WriteLine(data + " is a Right Sequence.");
        else
            Console.WriteLine(data + " is Not Right Sequence.");
        Console.ReadLine();
    }

Answer 5

public bool CheckBraces(string data)
{
    Stack<char> stack = new Stack<char>();
    foreach(char c in data){
        switch(c){
            case '(':
            case '[':
            case '{':
                stack.Push(c);
                break;
            case ')':
            case ']':
            case '}':
                if(!CheckMatch(stack.Pop(),c)){
                    return false;
                }
                break;
        }
   }
   return true;
}

private bool CheckMatch(char a, char b){
   return a=='(' && b==')' || 
          a=='[' && b==']' ||
          a=='{' && b=='}';
}