重言式判别

#include 
#include 
#include 

typedef struct DutyElement
{
    char data;
    int duty;
}DutyElement;

DutyElement DutyArray[100];          //定义加权数组

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild *rchild;
}BiTNode *BiTree;

 void InitDutyArray（char *s int n）         //根据输入的序列初始化加权数组
 {
    int i j;
    for （i = 0; i < n; i++）
    {
        DutyArray[i].data = s[i];
        switch （DutyArray[i].data）          //分别赋权值
         {
        case ‘~‘:
            DutyArray[i].duty = 3; break;
        case ‘&‘:
            DutyArray[i].duty = 2; break;
        case ‘|‘:
            DutyArray[i].duty = 1; break;
        default:
            DutyArray[i].duty = 0; break;
        }
    }
    for （i = 0; i < n; i++）
    {
        if （DutyArray[i].data == ‘（‘）        //是左括号的话则对运算符进行加权操作
         {
            for （j = i; j < n; j++）
            {
                if （DutyArray[j].duty != 0）
                    DutyArray[j].duty += 5;
            }
        }
        else
        {
            if （DutyArray[i].data == ‘）‘）          //右括号的话对运算符进行减权操作
             {
                for （j = i; j < n; j++）
                {
                    if （DutyArray[j].duty != 0）
                        DutyArray[j].duty -= 5;
                }
            }
        }
    }
}

 int SearchMinDutyOperator（int a int b）          //寻找权值最小的运算符，即为二叉树的根节点
 {
    int i n = a duty = 1000;
    for （i = a; i < b + 1; i++）
    {
        if （DutyArray[i].duty > 0 && DutyArray[i].duty < duty）
        {
            n = i;
            duty = DutyArray[i].duty;
        }
    }
    return n;
}

 int ParenthesesCloesed（int a int b）        //判断序列是否在最外层有一对括号
 {
    int i n = 0;
    for （i = a; i <= b; i++）
    {
        if （DutyArray[i].data == ‘（‘）
            n++;
        if （DutyArray[i].data == ‘）‘）
            n--;
        if （n == 0）
            break;
    }
    if （i == b）
        return 1;
    else
        return 0;
}

BiTree Create（int a int b）                //根据加权数组创建二叉树
 {
    BiTree p;
    if （DutyArray[a].data == ‘（‘ && DutyArray[b].data == ‘）‘ && ParenthesesCloesed（a b） == 1）  //去括号
    {
        a += 1;
        b -= 1;
    }
    if （a > b）
        p = NULL;
    else
    {
        if （a == b）
        {
            p = （BiTNode *）malloc（sizeof（BiTNode））;
            p->data = DutyArray[a].data;
            p->lchild = NULL;
            p->rchild = NULL;
        }
        else
        {
            int n;
            n = SearchMinDutyOperator（a b）;
            p = （BiTNode *）malloc（sizeof（BiTNode））;
            p->data = DutyArray[n].data;
            p->lchild = Create（a n - 1）;
            p->rchild = Create（n + 1 b）;
        }
    }
    return p;
}

void AssignValue（BiTree T char letter char binary）      //递归为对应的字母赋二进制字符
{
    if （T）
    {
        if （T->data == letter）
            T->da