数据结构 栈的应用(括号匹配)

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

//链式栈：括号匹配校验


#define	SUCCESS		0
#define FAILURE		1

typedef struct Node{
	struct Node *next;
}STNode_def;

typedef struct LinkStack{
	struct Node head;
	int size;
}STLinkStack_def;

typedef void (*STACKPRINT)(void*);
//栈初始化
STLinkStack_def* stack_init()
{
	int i = 0;
	STLinkStack_def* stack_ptr = (STLinkStack_def*)malloc(sizeof(STLinkStack_def));
	stack_ptr->size = 0;
	stack_ptr->head.next = NULL;
	
	return stack_ptr;
}

//栈顶插入元素
int stack_push(STLinkStack_def* stack, STNode_def* data)
{
	if (stack == NULL)
	{
		printf("param is null\n");
		return FAILURE;
	}
    data->next = stack->head.next;
    stack->head.next = data;

	stack->size++;

	return 0;
}


//栈顶弹出元素
int stack_pop(STLinkStack_def* stack)
{
	int pos = 0;
	if (stack == NULL)
	{
		printf("param is null\n");
		return FAILURE;
	}

	if (stack->size == 0)
	{
		return FAILURE;
	}

	STNode_def* p = &(stack->head);
    stack->head.next = p->next->next;
	stack->size--;

	return 0;
}


//获取栈顶元素
void* stack_top(STLinkStack_def* stack)
{
	if (stack == NULL)
	{
		printf("param is null\n");
		return NULL;
	}

	return stack->head.next;
}


//栈是否为空
int stack_empty(STLinkStack_def* stack)
{
	return stack->size>0 ?0:1;
}


//清空栈
int stack_clear(STLinkStack_def* stack)
{
	if (stack == NULL)
	{
		printf("param is null\n");
		return FAILURE;
	}

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

	return SUCCESS;
}

void stack_destory(STLinkStack_def* stack)
{
	free(stack);
}

//遍历栈，不需要清空栈
int stack_print(STLinkStack_def* stack, void (*STACKPRINT)(STNode_def*))
{

	if (stack == NULL)
	{
		printf("param is null\n");
		return FAILURE;
	}
	STNode_def* p = &(stack->head);
	while (p->next != NULL)
	{
		p = p->next;
		STACKPRINT(p);
	}

	return SUCCESS;
}


typedef struct MyData{
	STNode_def node;
	char c;
	int index;
}STMyData_def;


STMyData_def* create_malloc(char p, int i)
{
    STMyData_def* mydata = (STMyData_def*)malloc(sizeof(STMyData_def));
    mydata->c = p;
    mydata->index = i;
    
    return mydata;
}
void mydata_print(STMyData_def* info)
{
	printf("%c %d\n", info->c, info->index);
}

void show_error(char* str, int index)
{
    printf("%s\n", str);
    for (int i=0; i<index; i++)
    {
        printf(" ");
    }
    printf("^\n"); 
}

int isleftKH(char c)
{
    return c=='('?1:0;
}

int isrightKH(char c)
{
    return c==')'?1:0;
}

int isleftZKH(char c)
{
    return c=='{'?1:0;
}

int isrightZKH(char c)
{
    return c=='}'?1:0;
}

int isleftFKH(char c)
{
    return c=='['?1:0;
}

int isrightFKH(char c)
{
    return c==']'?1:0;
}


int main()
{
    char szBuff[1024]="{[{ helloworld}]]}";
	STLinkStack_def* stack= stack_init();
	
	int i = 0;
	while (szBuff[i] != '\0') 
	{
	    if (isleftKH(szBuff[i]) || isleftZKH(szBuff[i]) || isleftFKH(szBuff[i]))
	    {
	        stack_push(stack, create_malloc(szBuff[i], i));
	    }
	    
        if (isrightKH(szBuff[i]))
        {
            if (stack->size > 0)
            {
                STMyData_def* top = (STMyData_def*)stack_top(stack);
                if (isleftKH(top->c))
                {
                    stack_pop(stack);
                }
                else 
                {
                    printf("\")\"没有匹配到对应的\"(\":\n");
                    show_error(szBuff, i);
                }
            }
            else 
            {
                printf("\")\"没有匹配到对应的\"(\":\n");
                show_error(szBuff, i);
            }
        }
        else if (isrightZKH(szBuff[i]))
        {
            if (stack->size > 0)
            {
                STMyData_def* top = (STMyData_def*)stack_top(stack);
                if (isleftZKH(top->c))
                {
                    stack_pop(stack);
                }
                else 
                {
                    printf("\"}\"没有匹配到对应的\"{\":\n");
                    show_error(szBuff, i);
                }
            }
            else 
            {
                printf("\"}\"没有匹配到对应的\"{\":\n");
                show_error(szBuff, i);
            }
        }
        else if (isrightFKH(szBuff[i]))
        {
            if (stack->size > 0)
            {
                STMyData_def* top = (STMyData_def*)stack_top(stack);
                if (isleftFKH(top->c))
                {
                    stack_pop(stack);
                }
                else 
                {
                    printf("\"]\"没有匹配到对应的\"[\":\n");
                    show_error(szBuff, i);
                }
            }
            else 
            {
                printf("\"]\"没有匹配到对应的\"[\":\n");
                show_error(szBuff, i);
            }
        }
        
	    i++;
        
    }
	
	while(stack->size > 0)
    {
        STMyData_def *mydata = (STMyData_def*)stack_top(stack);
        printf("\"%c\"没有匹配到对应的括号:\n", mydata->c);
        show_error(szBuff, mydata->index);
        stack_pop(stack);
    }
	printf("empty:%d, size=%d\n", stack_empty(stack), stack->size);
	
	stack_print(stack, mydata_print);
	printf("\n");
	printf("empty:%d\n", stack_empty(stack));
	
	stack_clear(stack);
	printf("empty:%d\n", stack_empty(stack));
	stack_destory(stack);
	return 0;
}