平衡表达

Question

以下是确定符号平衡的代码。

如果表达式是平衡的，那么它应该打印适当的消息

GoogleAPIConnector connector = mock(GoogleAPIConnector.class);
when(connector.doSomeWork("someone@example.com")).thenReturn("hello world");

SomeClass someClass = new SomeClass(""someone@example.com");
someClass.setConnector(connector);

String result = someClass.work();
assertThat(result, equalTo("hello world");

verify(connector, times(1)).doSomeWork("someone@example.com");

这是代码

E.g. ((A+B))+(C+D)) --> Balanced

((A+B)+(C+D) ---> Unbalanced

((A+B)+(C+D}) --> Unbalanced

但它没有提供所需的输出。我调试了代码，但无法找到问题。

如何打印相应的信息？

Answer 1

您应该立即清理堆栈并在检测到不平衡的情况后立即停止处理，并在达到返回0时打印“平衡”。您应该从代码中的单个位置打印“不平衡”。

pop的一个分支在声明返回值时不会返回值，这很糟糕。

因此，pop可能会成为：

char pop(struct Stack **top,int flag)
{
        if(*top!=NULL && flag==0)
        {
                return '\0';
        }
        if(*top==NULL && flag ==1)
        {
                return '\0';
        }
        if(*top!=NULL && flag==1)
        {
                struct Stack *temp=*top;
                char op;
                op=(*top)->data;
                *top=(*top)->next;
                free(temp);
                return op;
        }
        // *top == null && flag == 0
        return 'O'; // for OK
}

我会添加一个clean方法 - 不需要，因为程序退出清理堆栈，但我更喜欢这样：

void clean(struct Stack *top) {
    struct Stack *next;
    while (top != NULL) {
        next = top->next;
        free(top);
        top = next;
    }
}

主要的一些变化：

int main(void)
{
        struct Stack *top=NULL;
        int i=0, err=0;
        ...
                        else
                        {
                                err = 1;
                                break;
                        }

                }
        }
        if (err || (pop(&top,0) == '\0')) {
            printf("\n The expression is un-balanced \n");
            clean(top);
            // return 1; optionally if you want to return a different value to environment
        }
        else {
            printf("\n The expression is balanced \n");
        }
        return 0;
}

Answer 2

你的pop功能错了。

如果top为null且flag为0，则您尚未处理。也可能是这种情况。

其次，为什么在**top签名中push\pop当你应该将top传递给它时。我认为它的签名应该有*top。

此外，您在if中使用push的原因。它不需要。你基本上是在做同样的事情。

Answer 3

您只需在此代码中进行简单修改即可。我从Find maximum depth of nested parenthesis in a string获取它。它也有助于了解细节。我认为这对你有帮助

#include <iostream>
using namespace std;

// function takes a string and returns the
// maximum depth nested parenthesis
int maxDepth(string S)
{
    int current_max = 0; // current count
    int max = 0;    // overall maximum count
    int n = S.length();

    // Traverse the input string
    for (int i = 0; i< n; i++)
    {
        if (S[i] == '(')
        {
            current_max++;

            // update max if required
            if (current_max> max)
                max = current_max;
        }
        else if (S[i] == ')')
        {
            if (current_max>0)
                current_max--;
            else
                return -1;
        }
    }

    // finally check for unbalanced string
    if (current_max != 0)
        return -1;

    return max;
}

// Driver program
int main()
{
    string s = "( ((X)) (((Y))) )";
    if (maxDepth(s) == -1)    
        cout << "Unbalance";
    else 
        cout << "Balance";
    return 0;
}


Time Complexity : O(n)
Auxiliary Space : O(1)

Answer 4

感谢您的建议。这是我下面相同问题的工作代码

#include<stdio.h>
#include<stdlib.h>

struct Stack{
char data;
struct Stack *next;
};

void push(struct Stack **top,char data)
{
        struct Stack *new_node;
        new_node=malloc(sizeof(struct Stack));
        new_node->data=data;
        new_node->next=*top;
        *top=new_node;
}
int compare(char str,char op)
{
        if( (op == '(' && str == ')') || (op == '{' && str == '}') || (op == '[' && str == ']') || (op == '<' && str == '>') )
                return 1;
        else
                return 0;
}
int pop(struct Stack **top,char str)
{
        char op,ret;
        struct Stack *temp=*top;
        if(*top==NULL)
                return 0;

        else if(*top!=NULL)
        {
                // Pop the element and then call comapre function
                op=(*top)->data;
                free(temp);
                *top=(*top)->next;
                return(ret=compare(str,op));
        }
}
void display(struct Stack *top)
{
        struct Stack *temp=top;
        while(temp!=NULL)
        {
                printf("%c ",temp->data);
                temp=temp->next;
        }
printf("\n");
}
int isNotEmpty(struct Stack *top)
{

        if(top!=NULL)
                return 1;
        else
                return 0;
}
int main(void)
{
        struct Stack *top=NULL;
        int i=0,y,flag=0;
        char str[]="((A+B)+(C+D)>",op;
        printf("\n Running the programe to check if the string is balanced or not ");
        for(i=0;str[i]!='\0';++i)
        {
                if( str[i] == '(' || str[i] == '[' || str[i] == '{' || str[i] == '<' )
                        push(&top,str[i]);
                else if( str[i] == ')' || str[i] == ']' || str[i] == '}' || str[i] == '>')
                {
                        y=pop(&top,str[i]);
                        if(!y)
                        {
                                printf("\n Unbalanced Expression ");
                                flag=1;
                        }
                }
        }
        if(!flag)
        {
                if(isNotEmpty(top))
                        printf(" \nUnbalanced Expression ");
                else
                        printf(" \n Balanced Expression ");
        }
        printf("\n");
        return 0;
}

Answer 5

检查此代码，超级简单易懂

package com.codewithsouma.stack;

import java.util.Arrays;
import java.util.List;
import java.util.Stack;

public class Expression {

    private final List<Character> leftBrackets = Arrays.asList('(','{','[','<');
    private final List<Character> rightBrackets = Arrays.asList(')','}',']','>');

    public boolean isBalanced(String input) {
        Stack<Character> stack = new Stack<>();

        for (char ch : input.toCharArray()) {
            if (isLeftBracket(ch))
                stack.push(ch);

            if (isRightBracket(ch)) {
                if (stack.isEmpty()) return false;

                char top = stack.pop();
                if (!bracketsMatch(top,ch)) return false;
            }
        }

        return stack.isEmpty();
    }

    private boolean isRightBracket(char ch) {
        return rightBrackets.contains(ch);
    }

    private boolean isLeftBracket(char ch) {
        return leftBrackets.contains(ch);
    }

    public boolean bracketsMatch(char left, char right){
        return leftBrackets.indexOf(left) == rightBrackets.indexOf(right);
    }

}

Answer 6

首先，我们创建一个哈希表并存储所有方括号，左方括号是键，值是其对应的右方括号。然后，我们从用户处获取一个表达式字符串，并创建一个字符数组。然后我们迭代数组并获取一个字符，然后检查该字符是否在左括号中（如果是左括号），然后放入堆栈（leftBracketContainer）中；否则，如果在右括号中则检查它是否在右括号中，然后弹出左括号从堆栈中查找哈希表中的右括号/对角括号，如果不匹配则匹配当前字符/括号（例如，我们的堆栈包含{此括号，因此其右括号为}）可从哈希图和当前字符中找到=]当前字符！=右括号）return false，否则我们继续。最后，当循环结束时，堆栈应该为空。 （如果堆栈包含另一个左括号，则意味着我们的表达式需要另一个右括号）；如果堆栈为空，则意味着我们的表达式是平衡的，否则就没有平衡。

N：B，当我们检查是否使用左括号时，isItLeftBracket(ch)会检查地图是否包含键，因为所有键都是左括号，就像我们在此处使用isItRightBracket(ch)来检查右括号的方式一样扼杀我们的地图包含该值，因为该地图的所有值都在右括号中

package com.codewithsouma.stack;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Stack;
    
    public class BalancedExpressionUsingMap {
        private final Map<Character,Character> map;
    
        public BalancedExpressionUsingMap() {
            this.map = new HashMap<>();
            map.put('(',')');
            map.put('[',']');
            map.put('<','>');
            map.put('{','}');
        }
    
        public boolean isBalanced(String expression){
            Stack<Character> leftBracketContainer = new Stack<>();
            char [] arrayOfCharacter = expression.toCharArray();
            for (char ch : arrayOfCharacter) {
                if(isItLeftBracket(ch))
                    leftBracketContainer.push(ch);
                else if(isItRightBracket(ch)){
                    if(leftBracketContainer.isEmpty()) return false;
    
                    char leftBracket = leftBracketContainer.pop();
                    char oppositeBracket = getOppositeBracket(leftBracket);
                    if (oppositeBracket != ch) return false;
                }
            }
    
            return leftBracketContainer.isEmpty();
        }
    
        private char getOppositeBracket(char leftBracket) {
            return map.get(leftBracket);
        }
    
        private boolean isItRightBracket(char ch) {
            return map.containsValue(ch);
        }
    
        private boolean isItLeftBracket(char ch) {
            return map.containsKey(ch);
        }
    }

Answer 7

您可以使用递归函数来跳过平衡的子表达式，并在不匹配时返回NULL，而不是为定界符分配堆栈：

#include <stdio.h>

const char *check(const char *s, char open) {
    while (*s) {
        switch (*s++) {
        case ')': return (open == '(') ? s : NULL;
        case ']': return (open == '[') ? s : NULL;
        case '}': return (open == '{') ? s : NULL;
        case '>': return (open == '<') ? s : NULL;
        case '(':
        case '[':
        case '{':
        case '<':
            s = check(s, s[-1]);
            if (s == NULL)
                return NULL;
            break;
        }
    }
    if (open) {
        /* closing delimiter not found */
        return NULL;
    }
    return s;
}

void test(const char *s) {
    printf("%s -> %s\n", s, check(s, 0) ? "Balanced" : "Unbalanced");
}

int main() {
    test("((A+B)+(C+D))");
    test("((A+B))+(C+D))");
    test("((A+B)+(C+D)");
    test("((A+B)+(C+D})");
    return 0;
}

输出：

((A+B)+(C+D)) -> Balanced
((A+B))+(C+D)) -> Unbalanced
((A+B)+(C+D) -> Unbalanced
((A+B)+(C+D}) -> Unbalanced

请注意，与您的主张相反，((A+B))+(C+D))是不平衡的。