数据结构：静态栈与动态栈的实现

#pragma once
#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
#define MAX_SIZE 100

typedef struct Stack
{
	DataType _arr[MAX_SIZE];//栈的元素最大个数
	int _top;//栈顶
	int _bottom;//栈低
	int len;//栈大小
}Stack,*Pstack;

// 栈的初始化 
void StackInit(Stack* s); 

// 入栈 
void StackPush(Stack* s, DataType data); 

// 出栈 
void StackPop(Stack* s); 

// 获取栈顶元素 
DataType StackTop(Stack* s); 

// 获取栈中元素个数 
int StackSize(Stack* s); 

// 检测栈是否为空 
int StackEmpty(Stack* s);

 test

#include"Stack.h"
void StackInit(Stack* S)
{
	S->_bottom = S->_top = 0;
	S->len = 0;
}

void StackPush(Stack* S, DataType data)
{
	if(S->len == MAX_SIZE)
	{
	printf("栈满溢出，添加失败！\n");
	return;
	}
	S->_top++;
	S->_arr[S->_top] = data;
	S->len++;
	printf(" %d 入栈成功!\n",data);
}

void StackPop(Stack* S)
{
	if(S->len == 0)
	{
	printf("栈为空！\n");
	return;
	}
	printf(" %d 出栈\n",S->_arr[S->_top]);
	S->_top--;
	S->len--;
	printf("此时栈顶元素为：%d\n",S->_arr[S->_top]);
}

DataType StackTop(Stack* S)
{
   if(S->len == 0)
	{
	printf("栈为空！\n");
	return;
	}
    printf("此时栈顶为： %d \n",S->_arr[S->_top]);
}

int StackSize(Stack* S)
{
	int ret = 0;
	ret = printf("栈中元素个数为：%d\n",S->len);
	return ret;
}

int StackEmpty(Stack* S)
{
   if(S->len == 0 )
	{
	printf("栈为空！\n");
	return 1;
	}
   else
   {
   printf("栈不为空！\n");
   return 0;
   }
}

main

#include"Stack.h"
test()
{
  Stack S;
  StackInit(&S);
  StackPush(&S, 1);
  StackPush(&S, 2);
  StackPush(&S, 3);
  StackPush(&S, 4);
  StackPush(&S, 5);
  StackSize(&S);
  StackTop(&S);
  StackPop(&S);
  StackPop(&S);
  StackEmpty(&S);



}
int main()
{
	test();
	system("pause");
}

动态栈

Stack.c

#include "stack.h"  
#include "Maze.h"  
  
void StackInit(Stack *S,int capacity)//栈初始化  
{  
    S->arr = (DataType*)malloc(capacity*sizeof(DataType));  
    if(NULL == S->arr)  
    {  
       printf("申请空间失败！\n");  
       return;  
    }  
    S->capacity = capacity;  
    S->size = 0;  
}  
  
  
void AddCapacity(Stack *S)//扩容  
{  
   if(NULL == S->arr)  
    {  
       printf("扩容失败\n");  
       return;  
    }  
   S->capacity = (DataType*)realloc(S->arr,sizeof(DataType)*(S->capacity)*2);//扩容为原来的二倍  
   if (NULL == S->arr)  
    {  
        printf("空间扩增失败!!!\n");  
        return;  
    }  
   S->capacity =2 * (S->capacity);  
}  
  
void PrintfStack(Stack *S)//打印栈  
{  
   int i = 0;  
   if(NULL == S->arr)  
    {  
       printf("打印失败\n");  
       return;  
    }  
   for(;i<S->size;i++)  
   {  
       printf("%d\n",S->arr[i]);  
   }  
   printf("\n");  
}  
  
void StackPush(Stack *S,DataType data)//入栈  
{  
    if(NULL == S->arr)  
    {  
       printf("入栈失败\n");  
       return;  
    }  
    if(S->capacity == S->size)//空间已满  
    {  
       AddCapacity(S);  
    }  
    S->arr[S->size] = data;  
    S->size++;  
}  
  
void StackPop(Stack *S)//出栈  
{  
   if(NULL == S->arr)  
    {  
       printf("出栈失败\n");  
       return;  
    }  
   S->size--;  
}  
  
DataType StackTop(PStack P)//获取栈顶元素  
{  
    return P->arr[P->size - 1];  
  /* int ret = 0; 
   if(NULL == S->arr) 
    { 
       printf("获取栈失败\n"); 
       return; 
    } 
   if(0 == S->size) 
   { 
   printf("栈为空！\n"); 
   return; 
   } 
   
   printf("栈顶元素为：%d \n", S->arr[S->size - 1]);*/  
}  
  
void StackSize(Stack *S)//获取元素个数  
{  
   if(NULL == S->arr)  
    {  
       printf("获取栈失败\n");  
       return;  
    }  
   printf("元素个数为：%d\n",S->size);  
}  
  
int StackEmpty(Stack *S)//检测栈是否为空  
{  
    if(NULL == S->arr)  
    {  
       printf("获取栈失败\n");  
       return 0;  
    }  
    if(S->size == 0)  
    {  
    printf("栈为空\n");  
    return 1;  
    }  
    return 0;  
}  

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef struct int DataType
typedef struct Stack
{
   DataType *_arr;
   int  capacity;
   int  size;
}Stack;
// 栈的初始化   
void StackInit(Stack *S, int capacity);  
  
// 入栈   
void StackPush(Stack *S, DataType data);  
  
// 出栈   
void StackPop(Stack *S);  
  
// 获取栈顶元素   
DataType StackTop(Stack *S);  
  
// 获取栈中元素个数   
void StackSize(Stack *S);  
  
// 检测栈是否为空   
int StackEmpty(Stack *S);