1. 堆栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

2. 堆栈的两种实现

2.1 数组实现堆栈

头文件声明函数.h

#pragma once
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
#define MAX 1024
//定义顺序栈的结构体，其中数组中存放指向元素的指针
struct seqstack
{
void * data[MAX];//存放数据的数组
int size;//栈中元素个数
};

typedef void * firststack;//定义void * 指针方便用户阅读
//初始化
firststack Initialization();
//入栈
void push_stack(firststack stack,void * data);
//出栈
void sport_stack(firststack stack);
//获得栈顶元素
void * Top_stack(firststack stack);
//获得栈的元素个数
int Size_stack(firststack stack);
//销毁
void Destroy_stack(firststack stack);

#ifdef __cplusplus
}
#endif // __cplusplus

数组栈函数的实现

#include"Sequencestack.h"
//顺序栈的结构
//	struct seqstack
//	{
//		void * data[MAX];//存放数据的数组
//		int size;//栈中元素个数
//	};
//typedef void * firststack;
//初始化
firststack Initialization()
{
struct seqstack * mystack = (struct seqstack *)malloc(sizeof(struct seqstack));//分配内存空间
memset(mystack,0,sizeof(struct seqstack));//初始化内存空间
mystack->size = 0;
return mystack;
}
//入栈
void push_stack(firststack stack,void * data)
{
if (NULL == stack)
{
return;
}
if (NULL == data)
{
return;
}
struct seqstack * mystack  = (struct seqstack *)stack;//将无类型指针转换为栈指针
mystack->data[mystack->size] = data;//插入元素
mystack->size++;
}
//出栈
void  sport_stack(firststack stack)
{
if (NULL == stack)
{
return;
}
struct seqstack * mystack  = (struct seqstack *)stack;
if (mystack->size == 0)
{
return;
}
mystack->data[mystack->size-1] = NULL;//将数组的尾元素即栈顶抛出
mystack->size--;
}
//获得栈顶元素
void * Top_stack(firststack stack)
{
if (NULL == stack)
{
return NULL;
}
struct seqstack * mystack  = (struct seqstack *)stack;
if (mystack->size == 0)
{
return NULL;
}
return mystack->data[mystack->size-1];	//数组末尾的元素
}
//获得栈的元素个数
int Size_stack(firststack stack)
{
if (NULL == stack)
{
return -1;
}
struct seqstack * mystack  = (struct seqstack *)stack;
return mystack->size;
}
//销毁
void Destroy_stack(firststack stack)
{
if (NULL == stack)
{
return;
}
free(stack);//只需要销毁自己创建的内存空间，用户创建的由用户删除，防止内存泄露
}

调用函数，实现数组栈

#include"Sequencestack.h"

struct person
{
char name[64];
int age;
};
void test()
{
person p1={"a",10};
person p2={"b",20};
person p3={"c",30};
person p4={"d",40};
person p5={"e",50};

firststack stack = Initialization();

push_stack(stack,&p1);
push_stack(stack,&p2);
push_stack(stack,&p3);
push_stack(stack,&p4);
push_stack(stack,&p5);

while (Size_stack(stack) > 0)
{
struct person * p1 = (struct person *)Top_stack(stack);//获取栈顶元素
sport_stack(stack);//弹出栈顶元素
printf("name:%s age:%d\n",p1->name,p1->age);
}
printf("%d\n",Size_stack(stack));
Destroy_stack(stack);
stack =NULL;
}
void main()
{
test();
}

2.2 链式栈的实现

头文件声明函数

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
struct Linknode
{
Linknode * next;
};
struct Linklist
{
Linknode header;
int size;
};
typedef void * linkstack;
//初始化
linkstack Init_linkstack();
//入栈
void push_linkstack(linkstack stack,void * data);
//出栈
void pop_linkstack(linkstack stack);
//查看栈顶元素
void * top_linkstack(linkstack stack);
//查看栈元素个数
int size_linkstack(linkstack stack);
//销毁栈
void Destroylinkstack(linkstack stack);
#ifdef __cplusplus
}
#endif // __cplusplus

函数实现

#include"liststack.h"
//typedef void * linkstack;
//struct Linknode
//{
//	Linknode * next;
//};
//struct Linklist
//{
//	Linknode header;
//	int size;
//};
//初始化
linkstack Init_linkstack()
{
Linklist * stack = (Linklist * )malloc(sizeof(Linklist));
if(NULL == stack)
return NULL;
stack->header.next = NULL;
stack->size =0;
return stack;
}
//入栈
void push_linkstack(linkstack stack,void * data)
{
if(NULL == stack)
return;
struct Linklist * mystack = (struct Linklist *)stack;
struct Linknode * mydata = (struct Linknode *) data;
mydata->next = mystack->header.next;
mystack->header.next =mydata ;
mystack->size++;
}
//出栈
void pop_linkstack(linkstack stack)
{
if(NULL == stack)
return;
struct Linklist * mystack = (struct Linklist *)stack;
if (mystack->size ==0)
{
return;
}
struct Linknode * node = mystack->header.next;
mystack->header.next = node->next;
mystack->size--;

}
//查看栈顶元素
void * top_linkstack(linkstack stack)
{
if(NULL == stack)
return NULL;
struct Linklist * mystack = (struct Linklist *)stack;
if (mystack->size ==0)
{
return NULL;
}
return mystack->header.next;
}
//查看栈元素个数
int size_linkstack(linkstack stack)
{
if(NULL == stack)
return -1;
struct Linklist * mystack = (struct Linklist *)stack;
return mystack->size;
}
//销毁栈
void Destroylinkstack(linkstack stack)
{
if(NULL == stack)
return;
free(stack);
}

函数调用及其结果

#include"liststack.h"

struct person
{
struct Linknode next;
char name[64];
int age;
};
void test()
{
person p1={NULL,"a",10};
person p2={NULL,"b",20};
person p3={NULL,"c",30};
person p4={NULL,"d",40};
person p5={NULL,"e",50};
linkstack stack =  Init_linkstack();
push_linkstack(stack,&p1);
push_linkstack(stack,&p2);
push_linkstack(stack,&p3);
push_linkstack(stack,&p4);
push_linkstack(stack,&p5);
while (size_linkstack(stack)>0)
{
struct person * p = (struct person *)top_linkstack(stack);
printf("name:%s age:%d\n",p->name,p->age);
pop_linkstack(stack);
}
int s =size_linkstack(stack);
printf("%d\n",s);
Destroylinkstack(stack);
}
void main()
{
test();
}