栈和栈的应用

栈的头文件

#ifndef __StackD__
#define __StackD__
  
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
   
#define CAPACITY 10//容量是10
#define MAX_ADD 10//一次扩容多少
typedef char DataType;

typedef struct StackD
{ 
	DataType* array;//当前位置
	int size;      //有效元素个数
	int capacity;  //容量
   
}StackD;




void StackDPrint(StackD* s);

void StackDInit(StackD* s); 

// 入栈 
void StackDPush(StackD* s, DataType data); 

// 出栈 
void StackDPop(StackD* s); 

// 获取栈顶元素 
DataType StackDTop(StackD* s); 

// 有效元素的个数 
int StackDSize(StackD* s); 

// 检测栈是否为空 
int StackDEmpty(StackD* s); 


void TestParentMatch(char *name);

void TestRPN(char * name);

int FindSpace(char * s);

#endif //__StackD__

函数文件

#include"StackD.h"

void StackDPrint(StackD* s)
{
	int i=0;
	assert(s);
	
	if(0==s->size)
	{
		printf("no yuansu!\n");
	  return ;
	}
	for(;i<s->size;i++)
	{
		printf("%d",*(s->array+i));

	}
}

void StackDInit(StackD* s)
{ 
	assert(s);
	s->array=(DataType*)malloc(sizeof(DataType)*CAPACITY);
    s->size=0;
	s->capacity=CAPACITY;
	
}
// 入栈 
void StackDPush(StackD* s, DataType data)
{
  assert(s);
  if(  s->capacity==s->size)
  {
	  DataType *tmp=( DataType *)realloc(s->array,(MAX_ADD+s->capacity)*sizeof(DataType));
	  if(NULL==tmp)
	  { 
		  printf("out of memory!\n");
		  return ;
	  }
	  else
	  {
		  s->array=tmp;
		  s->capacity+=MAX_ADD;
	  }
  }
  else
  {
	  *(s->array+s->size)=data;
	  s->size++;
  }
  }

// 出栈 
void StackDPop(StackD* s)
{
	assert(s);
	if(0==s->size)
	{
	  printf("no elment!\n");
	  return ;
	}
	s->size--;
	
}

// 获取栈顶元素 
DataType StackDTop(StackD* s)
{
	assert(s);
  if(0==s->size)
	{
	  printf("no elment!\n");
	  return -1;
	}
  return (s->array[(s->size)-1]);
}

// 有效元素的个数 
int StackDSize(StackD* s)
{
  assert(s);
  return s->size;
}
// 检测栈是否为空 
int StackDEmpty(StackD* s)
{
  assert(s);
  if(0==s->size)
  {
    return 0;
  }
  return 1;
}

测试文件

#include"StackD.h"
StackD str;

void TestStackDPush()
{
  StackDInit(&str);
  
  StackDPush(&str,2);
  StackDPush(&str,3);
  StackDPush(&str,4);
  StackDPush(&str,5);
  StackDPush(&str,6);
  StackDPush(&str,7);
  StackDPush(&str,8);
  StackDPush(&str,9);
  StackDPrint(&str);
	
  
}

void TestStackDTop()
{
	int ret=0;
  StackDInit(&str);
  
  StackDPush(&str,2);
  StackDPush(&str,3);
  StackDPush(&str,4);
  StackDPush(&str,5);
  StackDPush(&str,6);
  StackDPush(&str,7);
  StackDPush(&str,8);
  StackDPush(&str,9);
  StackDPrint(&str);

   ret=StackDTop(&str);
   printf("ret=%d\n",ret);
}

void TestStackDSize()
{
  int ret=0;
  StackDInit(&str);
  
  StackDPush(&str,2);
  StackDPush(&str,3);
  StackDPush(&str,4);
  StackDPush(&str,5);
  StackDPush(&str,6);
  StackDPush(&str,7);
  StackDPush(&str,8);
  StackDPush(&str,9);
  StackDPrint(&str);

  ret=StackDSize(&str);

}


int main ()
{
	//TestStackDPush();	
	//TestStackDTop();
	//TestStackDSize();
	
	
	
  return 0;
}

// 栈的应用 

2. 用栈解决括号匹配问题，测试用例见课件 

int main ()
{
	
	char a[] = "(())abc{[(])}" ; // 左右括号次序匹配不正确
        char b[] = "(()))abc{[]}" ; // 右括号多于左括号
	char c[] = "(()()abc{[]}" ; // 左括号多于右括号
	char d[] = "(())abc{[]()}" ; // 左右括号匹配正确
	
	TestParentMatch(d);
	
  return 0;
}

//2. 用栈解决括号匹配问题，测试用例见课件 
void TestParentMatch(char *name)
{
	int ret=0;
	DataType Top=0;
    unsigned int i=0;
	 StackDInit(&str); 
    for(;i<strlen(name);i++)
	{
		if((name[i]=='{')||(name[i]=='}') ||//是括号
           (name[i]=='[')||(name[i]==']') ||
		   (name[i]=='(')||(name[i]==')') )
		{
			  if((name[i]=='{')||(name[i]=='[')||(name[i]=='('))//是左括号
			  {
				
				StackDPush(&str, name[i]);//入栈
				continue;
			  }
			  else//是右括号 
			  {

					  //栈顶元素
							 Top=StackDTop(&str);
					if(((name[i]=='}')&&(Top=='{'))||//匹配
					  ((name[i]==')')&&(Top=='('))||
					  ((name[i]==']')&&(Top=='[')))
					{
					  StackDPop(&str);//出栈
					}
					else//不匹配
					{
					  printf("不匹配！\n");
					  return ;
					}
			  }
		}
		i++;//不是括号
	}
	ret=StackDEmpty(&str);
	if(0==ret)
		printf("括号匹配！\n");
	else
		printf("括号不匹配！\n");
}

3. 用栈求解后缀表达式值

int main ()
{
	
	
	char *name="12 3 4 + * 6 - 8 2 / +";
        TestRPN(name);
        return 0;
}



//3. 用栈求解后缀表达式值
int FindSpace(char * s)
{
	int count=0;
   
	while(*s!=' ')
	{
	  count++;
	  s++;
	}
	count++;
	return count;
}
void TestRPN(char * name)
{
	
	int top=0;
	int ret1=0;
	int left=0;
	int right=0;
	int ret=0;
	size_t i=0;
	StackDInit(&str);
  assert(name);
  for(;i<strlen(name);)
  {
			if(name[i]>='0'&&name[i]<='9')//是数字
		  {
			ret1=atoi(&(name[i]));
			StackDPush(&str, ret1);//入栈
			top=StackDTop(&str);
			ret=FindSpace(&(name[i]));
			i=i+ret;

		  }
		else
		{
			    right=StackDTop(&str);
					 StackDPop(&str);//出栈
					 top=StackDTop(&str);
				left=StackDTop(&str);
					 StackDPop(&str);//出栈
					 top=StackDTop(&str);
		  switch(name[i])
		  {
		  case '+':
				
				StackDPush(&str, (right+left));//入栈
				top=StackDTop(&str);
				break;
		  case'-':
				StackDPush(&str, (left-right));//入栈
				top=StackDTop(&str);
				break;
		  case'*':
				StackDPush(&str, (right*left));//入栈
				top=StackDTop(&str);
				break;
		  case'/':
				StackDPush(&str, (left-right));//入栈
				top=StackDTop(&str);
				break;
		  }
		  i+=2;
		}
		
  }
  printf("the value is %d \n",StackDTop(&str));

}