栈的基本操作和简单应用

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;
}