How can I go about finding balance in a string in C? - c

Question

I want this program to recursively solve this using a stack implementation with push and pop. I have the push and pop done, as well as these functions:
A string the users enter can only be made up of these characters. Any other characters and it returns unbalanced.
'(', ')', '{', '}', '[', ']'
An example of a balanced string is like this
()
(())
()()
{()()}
[]
[()[]{}]()
etc..
An unbalanced string looks like this:
{}}
()[}
[()}
etc..
This is the recursive definition of a balanced string:
(BASIS)The empty string is balanced
(NESTING) If s is also a balanced string then (s), [s], and {s} is balanced.
(CONCATENATION) If A and B are both strings, then AB is also balanced.
I do not know what my base case would be or how to implement this in recursion. I can without but I want to learn recursion. Any help?

Answer 1

I think you want to implement "Parenthesis Balanced" problem.
You can solve it easily by using stack without any recursion operation.
You can follow this.
//stk is a stack
// s is a string
for(int i=0; i<s.size(); i++)
{
if(str[i]=='('||str[i]=='[')
stk.push(s[i]);
else if(str[i]==')' && !stk.empty() && stk.top()=='(')
stk.pop();
else if(str[i]==']' && !stk.empty() && stk.top()=='[')
stk.pop();
}
Then by using a flag you can find this string of parenthesis is balanced or not.
You can get help from this question. Same to your question(Basic Recursion, Check Balanced Parenthesis) I think.

Answer 2

Well, having double as your stack's element type is rather wasteful, but I'll play along:
int is_balanced(char *ins) {
SPointer st = stk_create(),
int rval = 1;
for (int i = 0; i < strlen(ins); i += 1) {
int c = ins[i];
if ('(' == c) stk_push(st, (ElemType)')');
else if ('[' == c) stk_push(st, (ElemType)']');
else if ('{' == c) stk_push(st, (ElemType)'}');
else if (')' == c || ']' == c || '}' == c) {
if (stk_empty(st) || c != stk_pop(st)) {
rval = 0;
break;
}
} else {
rval = 0;
break;
}
}
if (! stk_empty(st)) rval = 0;
stk_free(st);
return rval;
}

Answer 3

Recursively done...
char* balanced_r(char* s, int* r)
{
const char* brackets= "([{\0)]}";
char *b = brackets;
if (s == 0) return s;
if (*s == 0) return s;
while (*b && *b != *s) b++;
if (*s == *b)
{
s = balanced_r(s+1, r);
if (*s != *(b+4)) *r = 0;
return balanced_r(s + 1, r);
}
return s;
}
int balanced(char* s)
{
int r = 1;
balanced_r(s, &r);
return r;
}

Answer 4

Here is a demonstrative program written in C++ that you can use as an algorithm and rewrite it in C
#include <iostream>
#include <iomanip>
#include <stack>
#include <cstring>
bool balance( const char *s, std::stack<char> &st )
{
const char *open = "({[<";
const char *close = ")}]>";
if ( *s == '\0' )
{
return st.empty();
}
const char *p;
if ( ( p = std::strchr( open, *s ) ) != nullptr )
{
st.push( *s );
return balance( s + 1, st );
}
else if ( ( p = std::strchr( close, *s ) ) != nullptr )
{
if ( !st.empty() && st.top() == open[p-close] )
{
st.pop();
return balance( s + 1, st );
}
else
{
return false;
}
}
else
{
return false;
}
}
int main()
{
for ( const char *s : {
"()", "(())", "()()", "{()()}", "[]", "[()[]{}]()",
"{}}", "()[}", "[()}"
} )
{
std::stack<char> st;
std::cout <<'\"' << s << "\" is balanced - "
<< std::boolalpha << balance( s, st )
<< std::endl;
}
return 0;
}
The program output is
"()" is balanced - true
"(())" is balanced - true
"()()" is balanced - true
"{()()}" is balanced - true
"[]" is balanced - true
"[()[]{}]()" is balanced - true
"{}}" is balanced - false
"()[}" is balanced - false
"[()}" is balanced - false