数据结构——栈的实现（C语言）

什么是栈？

1. 栈是数据结构中基础的逻辑结构。
2. 栈的特点：遵循先进后出，栈具有记忆性。
3. 栈的种类：顺序栈和链式栈

顺序栈的实现

1.容易理解的顺序栈

#include<stdio.h>
#include<stdlib.h>
#define SIZEMAX 10 //栈的长度
#define OK 1	  //返回状态
#define ERROR -1 //返回状态
typedef int Status;
typedef int Elemtype;
typedef struct 
{
	Elemtype *arr;
	int piont;
} Stack;
//初始化栈
Status InitStack(Stack &S)
{
	S.arr=new Elemtype[SIZEMAX];//栈的长度
	S.piont=0;
	if(!S.arr)
	{
	return ERROR;
	}else
	{
	return OK;
	}
	
	
}
//入栈
Status Push(Stack &S,Elemtype data)
{
	//判断栈是否满
	if(S.piont==(SIZEMAX-1))
	{
		return ERROR;
	}else
	{
	S.arr[S.piont++]=data;
	return OK;
	}
}
//出栈
Status Pop(Stack &S,Elemtype &data)
{
	if(S.piont==0)
	{
	return ERROR;
	}else
	{
	data=S.arr[S.piont--];//data接受了弹出栈的数据
	return OK;
	}
}
//清空栈
Status Clear(Stack &S)
{
	S.piont=0;
	return OK;

}
//获取栈内头元素
Elemtype getTop(Stack S)
{
	return S.arr[--S.piont];
}
//获得栈的长度(栈内已经存入的元素的数目)
int getLength(Stack S)
{
	int num=0;
	while(S.piont)
	{
	S.piont--;
	num++;
	}
	return num;
}
//销毁栈
void destroyStack(Stack &S)
{
	free(S.arr);
	S.piont=0;
}

2.不容易理解的顺序栈

#include<stdio.h>
#include<stdlib.h>
#define SIZEMAX 10 //栈的长度
#define OK 1	  //返回状态
#define ERROR -1 //返回状态
typedef int Status;
typedef struct 
{
	int *top; //基地址
	int *base;//基地址
	int Sizeof;//栈的长度
} Stack;
//初始化栈
Status InitStack(Stack &S)
{
	S.Sizeof=SIZEMAX;
	S.top=new int[SIZEMAX];//为栈申请一段连续的内存地址
	S.base=S.top;
	if(S.top)
	{
	return OK;
	}else
	{
	return ERROR;
	}
}
Status Push(Stack &S,int data)
{
	if(S.top-S.base==S.sizeof)//判断栈是否满
	{
		*(S.top++)=data;
		return OK;
	}else
	{
		return ERROR;
	}

}
//弹栈，用data来接受弹出的元素
Status Pop(Stack &S,int &data)
{
	if(S.base==S.top)
	{
	return ERROR;
	}else
	{
	data=*(--S.top);
	return OK;
	}

}
//清空栈
Status ClearStack(Stack &S)
{
	S.top=S.base;
	return OK;
}
Status DestroyStack(Stack &S)
{
	free(S.top);
	S.top-NULL;
	S.baes=NULL;
	S.Sizeof=0;
	return OK;
}

链式栈的实现

1. 故名思意使用链表来实现链式栈
2. 栈遵循先进后出的规则
3. 我们就遵循栈的规则应该用头插法来实现链式栈

#include<stdio.h>
#include<stdlib.h>
#define SIZEMAX 10 //栈的长度
#define OK 1	  //返回状态
#define ERROR -1 //返回状态
typedef int Status;
typedef int Elemtype;
typedef struct _Node
{
	Elemtype data;
	struct _Node *next;
}Stack,*PStack;
//初始化栈
Status InitStack(PStack &S)
{
	S=NULL;
	return OK;
}
//压栈
Status Push(PStack &S,Elemtype data)
{
	PStack Temp=new Stack;
	Temp->data=data;
	Temp->next=S;
	S=Temp;
	return OK;
}

//弹栈
Status Pop(PStack &S,Elemtype &data)
{
	if(!S)//判断栈是否为空
	{
	return ERROR;
	}else
	{
	PStack Temp=new Stack;
	data=S->data;
	Temp=S;
	S=Temp->next;//S=S->next;
	free(Temp);//释放内存
	return OK;
	}
}
Elemtype getStack_Top(PStack S)
{
	return S->data;
}
int getStack_Length(PStack S)
{	
	int num=0;
	while(S)
	{
	S=S->next;
	num++;
	}	
	return num;
}

总结

栈的类型就这两种动态栈(链式栈)和静态栈(顺序栈)
栈具有记忆性能了解前几次所存储的数据
栈作用：非递归遍历二叉树，递归的理解，四则运算后缀表达式等等。。
经典的还属汉诺塔问题(非常有趣)，大家可以去了解一下。
代码应该不够简洁，但应该通俗易懂。
希望大家能对以上代码分析查看。