Stack.h
#define _CRT_SECURE_NO_WARNING 1
#pragma once
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
typedef int DataType;
typedef struct Stack
{
DataType* _array;//数据块指针
int capacity; //空间容量
int _top;//栈的栈顶(有效元素的个数)
}Stack;
//栈的初始化
void StackInit(Stack* s,int capacity);
//入栈
void StackPush(Stack* s,DataType data);
//出栈
void StackPop(Stack* s);
//获取栈顶元素
DataType StackTop(Stack* s);
//获取栈中元素个数
int StackSize(Stack* s);
//检测栈是否为空
int StackEmpty(Stack* s);
//打印栈中的元素
void StackPrint(Stack* s);
//括号匹配问题
int IsBrackets(char* pCur);
void IsMatch(Stack* s,char* a);//检测括号是否匹配
//逆波兰表达式(后缀表达式)
void PolishNotation(char* a,Stack* s);
Stack.c
#define _CRT_SECURE_NO_WARNING 1
#include "Stack.h"
//栈的初始化
void StackInit(Stack* s,int capacity)
{
if(NULL == s)
return;
s->_array = (DataType*)malloc(sizeof(DataType)*capacity);
if(NULL == s->_array)
{
printf("空间申请失败!!!\n");
return;
}
s->capacity = capacity;
s->_top = 0;
}
//扩容
void StackCapacityAdd(Stack* s)
{
int newcapacity = (s->capacity)*2;
if(NULL == s)
return;
s->_array = (DataType*)realloc(s->_array,sizeof(DataType)*newcapacity);
if(NULL == s->_array)
{
printf("空间扩容失败!!!\n");
return;
}
s->capacity = newcapacity;
}
//入栈
void StackPush(Stack* s,DataType data)
{
assert(s);
if(s->_top == s->capacity)
{
printf("栈已满!!!\n");
StackCapacityAdd(s);
}
s->_array[s->_top] = data;
s->_top++;
}
//出栈
void StackPop(Stack* s)
{
assert(s);
if(0 == s->_top)
{
printf("栈已空!!!\n");
return;
}
s->_top--;
}
//获取栈中元素个数
int StackSize(Stack* s)
{
if(NULL == s)
{
printf("栈为空!!!\n");
return 0;
}
return s->_top;
}
//检测栈是否为空
int StackEmpty(Stack* s)
{
if(s->_top == 0)
return 0;
return 1;
}
//获取栈顶元素
DataType StackTop(Stack* s)
{
assert(s);
if(0 == s->_top)
{
printf("栈为空没有元素!!!\n");
return 0;
}
return s->_array[s->_top-1];
}
//打印栈中的元素
void StackPrint(Stack* s)
{
int i = 0;
assert(s);
for( ; i < s->_top ;i++)
{
printf("%d--->", s->_array[i]);
}
printf("NULL\n");
}
//括号匹配问题
int IsBrackets(char* pCur)//检测是否为括号
{
if(NULL == pCur)
return 0;
if( *pCur == '(' || *pCur == ')' ||
*pCur == '[' || *pCur == ']' ||
*pCur == '{' || *pCur == '}')
return 1;
else
return 0;
}
void IsMatch(Stack* s,char* a)//检测括号是否匹配
{
int i = 0;
int len = strlen(a);
if(NULL == s)
return;
if(NULL == a)
return;
for( ; i < len;i++)
{
if(IsBrackets(a+i))
{
//1.如果是左括号,入栈
if( ('(' == a[i]) || ('[' == a[i]) || ('{' == a[i]) )
{
StackPush(s,a[i]);
continue;
}
else//那么必定是右括号
{
if(StackEmpty(s))
{
printf("右括号多于左括号!!!\n");
return;
}
else
{
char top = StackTop(s);
if( (top == '(' && a[i] == ')') ||
(top == '[' && a[i] == ']') ||
(top == '{' && a[i] == '}'))
StackPop(s);
else
{
printf("括号次序不正确!!!\n");
return;
}
}
}
}
}
//如果上面循环完成以后,栈为空匹配正确,栈不为空说明左括号多
if(StackEmpty(s))
{
printf("括号匹配正确!!!\n");
return;
}
else
printf("左括号多于右括号!!!\n");
}
//逆波兰表达式(后缀表达式)
void PolishNotation(char* a,Stack* s)
{
int len = 0;
int i = 0;
int flag = 0;
int num = 0;
assert(s);
assert(a);
len = strlen(a);
for( ; i < len;i++)
{
//1.字符类型数字,先转换成数字
if( a[i]>='0' && a[i] <='9')
{
num = num*10 + a[i] -'0';
flag=1;//区分是数字还是字符类数字
}
//2.数字入栈
else if(a[i] == ' ' && flag == 1)
{
StackPush(s,num);
num = 0;
flag = 0;//每一次取完将其置零
}
//3.遇到操作符,取栈顶数字(其中先取出的为右操作数)
else
{
int left = 0;
int right = 0;
if(a[i] == ' ')
continue;
right = StackTop(s);
StackPop(s);
left = StackTop(s);
StackPop(s);
switch(a[i])
{
case '+':
StackPush(s,left+right);
break;
case '-':
StackPush(s,left-right);
break;
case '*':
StackPush(s,left*right);
break;
case '/':
StackPush(s,left/right);
break;
default:
break;
}
}
}
}
test.c
#define _CRT_SECURE_NO_WARNING 1
#include "Stack.h"
int main()
{
Stack s;
char a[] = "(())abc{[(])}";
char b[] = "(()))abc{[]}";
char c[] = "(()()abc{[]}";
char d[] = "(())abc{[]()}";
StackInit(&s,20);
/*StackPrint(&s);
StackPush(&s,1);
StackPush(&s,2);
StackPush(&s,3);
StackPush(&s,4);
StackPush(&s,5);
StackPush(&s,6);
StackPrint(&s);*/
//StackPop(&s);
//StackPrint(&s);
/*StackTop(&s);
StackSize(&s);*/
IsMatch(&s,a);
IsMatch(&s,b);
IsMatch(&s,c);
IsMatch(&s,d);
return 0;
}