栈的应用就进匹配_笔记

1+2+3 aaa)bbbbbb((cccc)
判断这段字符串中的括号是否对上如果没有对上是那一个没有对上

判断他是否是括号不是就执行下一次
匹配到左括号将它压入堆栈
匹配到右括号判断栈是否为空，空表示右括号没有匹配的左括号
不为空执行弹栈，如果是左就匹配
判断此时的栈如果为空，左括号没有匹配的右括号


//链式栈的节点
typedef struct LINKNODE
{
    struct LINKNODE*next;
}LinkNode;

//链式栈
typedef struct LINKSTACK
{
    LinkNode head;
    int size;

}LinkStack;


class linkstack
{
public:
    linkstack();
    ~linkstack();
public:
    LinkStack* Stack;

public:
    //入栈
    void push_back(LinkStack* stack,LinkNode* data);
    //出栈
    void pop_back(LinkStack* stack);
    //返回栈顶元素
    LinkNode* Top_LinkStack(LinkStack* stack);
    //返回栈元素的个数
    int Size_LinkStack(LinkStack* stack);
    //清空栈
    void Clear_LinkStack(LinkStack* stack);


};

.cpp


linkstack::linkstack()
{
    Stack = new LinkStack;

    Stack->head.next = NULL;
    Stack->size = 0;
}

linkstack::~linkstack()
{
    if (Stack == NULL)
    {
        return;
    }

    delete Stack;


}

//入栈
void linkstack::push_back(LinkStack* stack, LinkNode* data)
{
    if (stack == NULL || data == NULL)
    {
        return;
    }

    data->next = stack->head.next;
    stack->head.next = data;
    stack->size++;
}

//出栈
void linkstack::pop_back(LinkStack* stack)
{
    if (stack == NULL || stack->size == 0)
    {
        return;
    }

    LinkNode* pNext = stack->head.next;
    stack->head.next = pNext->next;

    stack->size--;
}

//返回栈顶元素
LinkNode* linkstack::Top_LinkStack(LinkStack* stack)
{
    if (stack == NULL || stack->size == 0)
    {
        return NULL;
    }

    return stack->head.next;
}

//返回栈元素的个数
int linkstack::Size_LinkStack(LinkStack* stack)
{
    if (stack == NULL )
    {
        return -1;
    }

    return stack->size;
}

//清空栈
void linkstack::Clear_LinkStack(LinkStack* stack)
{
    if (stack == NULL || stack->size == 0)
    {
        return;
    }

    stack->head.next = NULL;
    stack->size = 0;
}

main.cpp


typedef struct MYCHAR
{
    LinkNode node;
    char* pAddress;
    int index;

}MyChar;

int IsLeft( char c)
{
    return c == '(';
}

int IsRight(char c)
{
    return c == ')';
}

MyChar* CreateMyChar(char* p,int index)
{
    MyChar* mychar = new MyChar;
    mychar->pAddress = p;

    mychar->index = index;


    return mychar;
}

void ShowError(char* str,int pos)
{
    cout << str << endl;
    for (int i = 0; i < pos; i++)
    {
        cout << " ";
    }

    cout << "A";
}

int main()
{
    char* str = "1+2+3(aaabbbbbb(cccc)";
    char* p = str;
    int index = 0;

    linkstack* l = new linkstack();


    while (*p != '\0')
    {
        //如果是左括号 直接进栈
        if (IsLeft(*p))
        {
            l->push_back(l->Stack, (LinkNode*)CreateMyChar(p,index));
        }

        //如果是右括号 从栈顶弹出元素 
        if (IsRight(*p))
        {
            if (l->Size_LinkStack(l->Stack) >0)
            {
                MyChar* mychar = (MyChar*)l->Top_LinkStack(l->Stack);
                if (IsLeft(*mychar->pAddress))
                {
                    l->pop_back(l->Stack);

                    delete mychar;
                }
            }
            else
            {
                cout << "右括号没有匹配的左括号"<<endl;
                ShowError(str,index);
                break;
            }
        }


        p++;
        index++;
    }

    while (l->Size_LinkStack(l->Stack) > 0)
    {
        MyChar* mychar = (MyChar*)l->Top_LinkStack(l->Stack);
        cout << "左括号没有匹配的右括号"<<endl;
        ShowError(str,mychar->index);
        l->pop_back(l->Stack);

        delete mychar;
    }


    delete l;
    return 0;
}

栈的应用就进匹配_笔记

猜你喜欢