Question

//JOSE DENNIS CHUA 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define bool int

/* structure of a stack node */
struct sNode
{
   char data;
   struct sNode *next;
};

/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);

/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);

/* Returns 1 if character1 and character2 are matching left
   and right Parenthesis */
bool isMatchingPair(char character1, char character2)
{
   if(character1 == '(' && character2 == ')')
     return 1;
   else
     return 0;
}

/*Return 1 if expression has balanced Parenthesis */
bool areParenthesisBalanced(char exp[])
{
   int i = 0;

   /* Declare an empty character stack */
   struct sNode *stack = NULL;

   /* Traverse the given expression to check matching parenthesis */
   while(exp[i])
   {
      /*If the exp[i] is a starting parenthesis then push it*/
      if(exp[i] == '(')
        push(&stack, exp[i]);

      /* If exp[i] is a ending parenthesis then pop from stack and 
          check if the popped parenthesis is a matching pair*/
      if(exp[i] == ')')
      {

          /*If we see an ending parenthesis without a pair then return false*/
         if(stack == NULL)
           return 0; 

         /* Pop the top element from stack, if it is not a pair 
            parenthesis of character then there is a mismatch.
            This happens for expressions like {(}) */
         else if ( !isMatchingPair(pop(&stack), exp[i]) )
           return 0;
      }
      i++;
   }

   /* If there is something left in expression then there is a starting
      parenthesis without a closing parenthesis */
   if(stack == NULL)
     return 1; /*balanced*/
   else
     return 0;  /*not balanced*/
} 

/* UTILITY FUNCTIONS */
/

*driver program to test above functions*/
int main()
{
  char exp[100];

printf("Enter String: ");
  gets(exp);
  if(areParenthesisBalanced(exp))
    printf("\n Balanced ");
  else
    printf("\n Not Balanced ");  \
  getchar();
}    

/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data)
{
  /* allocate node */
  struct sNode* new_node =
            (struct sNode*) malloc(sizeof(struct sNode));

  if(new_node == NULL)
  {
     printf("Stack overflow \n");
     getchar();
     exit(0);
  }           

  /* put in the data  */
  new_node->data  = new_data;

  /* link the old list off the new node */
  new_node->next = (*top_ref);  

  /* move the head to point to the new node */
  (*top_ref)    = new_node;
}

/* Function to pop an item from stack*/
int pop(struct sNode** top_ref)
{
  char res;
  struct sNode *top;

  /*If stack is empty then error */
  if(*top_ref == NULL)
  {
     printf("Stack overflow \n");
     getchar();
     exit(0);
  }
  else
  {
     top = *top_ref;
     res = top->data;
     *top_ref = top->next;
     free(top);
     return res;
  }
}

这是我的代码，我不知道在哪里放置用于分隔括号的布尔表达式的代码..任何人都可以给我代码..

问题定义。

在计算机科学中，布尔表达式是编程语言中的表达式，在计算时产生布尔值，即true或false之一。布尔表达式可以由布尔常量true或false，布尔类型变量，布尔值运算符和布尔值函数[wiki]的组合组成。布尔表达式的示例如下：

x<=1
((x>0) && (x<10))
(!x || !y)

在将布尔表达式分组到另一个布尔表达式中时使用括号，您的任务是开发一个模块，该模块将根据表达式中存在的括号配对来识别给定的布尔表达式是否正确。

示例程序输出。

Input String (Boolean Expression): xValue<=1

Identification Result: Parenthesis pairs complete

Input String (Boolean Expression): ((teen>9) && (teen<20))

Identification Result: Parenthesis pairs complete

Input String (Boolean Expression): (!myAge) || !yourAge)

Identification Result: Parenthesis pairs incomplete

Input String (Boolean Expression): (total<=0( || )total>=10)

Identification Result: Parenthesis pairs incomplete

强制性要求。

应用Stack ADT概念解决给定问题。您可以自由选择数组或链表实现，前提是执行期间程序的唯一限制是内存空间。

Answer 1

从您的评论中，您要解决的是如何从括号中解析布尔表达式。

从您的帖子中假设以下类别的“令牌”：

括号
算
标识符

<强>算
运算符是与标识符相关联的一个或多个符号字符。评估符号的结果产生布尔结果。

C和C ++语言中的一些 Boolean 运算符：

==, !=, <, <=, >, >=,  
&&, ||

<强>标识符
从您的帖子中，标识符可以是数字或“变量名称” 示例：49, myVar, ketchup96

<强>括号
您的任务的基础是识别和匹配括号对，打开和关闭。另一部分是识别有效的布尔表达式。

解析树
用于解析的公共数据结构是二叉树。父节点是运算符，其两个子节点是标识符。括号确定父母和子女的关系，这是你的任务的练习。

使用钢笔/铅笔和纸，写一个简单的布尔表达式，例如：4 < 5 读取标识符：4，创建节点并放入树中。读取运算符并创建节点。运算符成为父级，标识符成为左子级：

   <
 /
4

读入下一个标识符，创建节点，添加为运算符的右子项：

  <
 / \
4   5

记下步骤。采取另一个表达式遵循相同的步骤。

现在添加第二个表达式和括号 您如何更改算法（步骤）以处理括号和另一个表达式？

继续优化您的算法最后，编写算法代码测试你的代码。

<强> ADT
在网上搜索“ADT教程”以及与您的教师讨论关于ADT。

解析字符串
在Web和StackOverflow中搜索“C ++解析输入标记”。

Answer 2

你使问题变得更加困难。

x<=1
((x>0) && (x<10))
(!x || !y)

这些表达式只允许括号，而不是括号或大括号。因此，没有必要保持堆栈记录时遇到括号，括号和括号中的哪一个...只需保留一个记录当前嵌套深度的数字。

我建议您使用递归来验证输入。具体来说......考虑到表达式到目前为止是否合法，从左到右扫描，如果你达到“（”在合法的地方然后递归调用你的验证函数传递下一个字符的地址......它应该返回当它消耗匹配的“）”时，让你继续验证表达式的其余部分，因为“（）”产生了一个布尔值。

括号与布尔表达式匹配

问题定义。

示例程序输出。

强制性要求。

2 个答案: