数据结构(c语言实现)——栈

线性栈

//动态分配内存空间线性表，栈顶标记总是标记栈顶元素上面第一个空间
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define max 51
//线性表最大
#define initSize 100 


 struct People
{
	char name[max];
	char ID[max];
};
typedef struct 
{
	People* people;
	int top;	//线性表当前位置
}Stack;

void initStack(Stack &stack);//初始化栈
bool stackEmpty(Stack stack);//判断是否为空栈
bool stackFull(Stack stack);//判断是否为满栈
bool push(Stack &stack, People peo);//入栈
bool pop(Stack &stack ,People& peo);//出栈
People getPop(Stack &stack);//读取栈顶元素
void printPeo(People peo);//输出people

void main()
{
	Stack stack;
	initStack(stack);

	People peo[4] = { {"李参政" , "0418"} , { "参政" ,"0418"} , {"政" ,"0418"} ,{"李" ,"0418"} };
	for (int i = 0; i < 4; i++)
	{
		push(stack, peo[i]);
	}
	for (int i = 0; i < 4; i++)
	{
		People peo;
		pop(stack, peo);
		printf("%d --------\n" , 3-i);
		printPeo(peo);
	}
	free(stack.people);

}
void initStack(Stack& stack)//初始化栈
{
	stack.people = (People*)malloc(sizeof(People) * initSize);//动态分配initSize个大小与People相等的空间
	stack.top = 0;//指向栈的第一个空间，此时栈为空栈
}

bool stackEmpty(Stack stack)//判断是否为空栈
{
	if (stack.top == 0)
		return true;
	else
		return false;
}
bool stackFull(Stack stack)//判断是否为满栈
{
	if (stack.top >= initSize)
		return true;
	else
		return false;
}
bool push(Stack& stack, People peo)//入栈
{
	//栈满
	if (stackFull(stack))
		return false;
	int top = stack.top;
	stack.people[top] = peo;//元素入栈
	++stack.top;//栈顶向上移
	return true;
}
bool pop(Stack& stack , People &peo)//出栈
{
	if (stackEmpty(stack))
		return false;
	else
	{
		--stack.top;//栈顶向下移
		int top = stack.top;
		peo = stack.people[top];//元素出栈
		
	}
		
	return true;
		
}
People getPop(Stack& stack)//读取栈顶元素
{
	if (!stackEmpty(stack))
	{
		int i = stack.top - 1;
		return stack.people[i];
	}
	
}
void printPeo(People peo)//输出people
{
	printf("name = %s\n", peo.name);
	printf("ID = %s\n", peo.ID);
	printf("-------------------------------\n");
}

链栈

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define max 51
//线性表最大
#define initSize 100 

struct People
{
	char name[max];
	char ID[max];
};
typedef struct LNode
{
	People people;
	struct LNode *next;
}LNode , *linkStack;
People peo = { "栈底" ,"栈底" };

void initStack(linkStack& stack);//初始化栈
bool stackEmpty(linkStack stack);//判断是否为空栈
bool push(linkStack& stack, People peo);//入栈
bool pop(linkStack& stack, People& peo);//出栈
People getPop(linkStack stack);//读取栈顶元素
bool destroy(linkStack& stack);//销毁空链栈
void printPeo(People peo);//输出people

void main()
{
	linkStack stack;
	initStack(stack);
	People peo[4] = { {"李参政" , "0418"} , { "参政" ,"0418"} , {"政" ,"0418"} ,{"李" ,"0418"} };
	for (int i = 0; i < 4; i++)
		push(stack, peo[i]);//依次插入peo[i]
	for (int i = 0; i < 4; i++)
	{
		People peo;
		pop(stack , peo);
		printPeo(peo);
	}
	destroy(stack);
}

void initStack(linkStack& stack)//初始化栈
{
	LNode* stackBottom = (LNode*)malloc(sizeof(LNode));//创建栈底节点
	stackBottom->next = NULL;
	stack = (linkStack)malloc(sizeof(LNode));
	stack->next = stackBottom;//头指针指向栈底节点
}
bool stackEmpty(linkStack stack)//判断是否为空栈
{
	if (stack->next->next == NULL)//判断头指针是否指向占地节点
		return true;
	return false;
}
bool push(linkStack& stack, People peo)//入栈
{
	LNode* newpeo = (LNode*)malloc(sizeof(LNode));//创建新的节点
	newpeo->people = peo;//修改新节点数据域
	newpeo->next = stack->next;//新节点指向原栈栈顶元素
	stack->next = newpeo;//栈顶指针直线新节点
	return true;
}
bool pop(linkStack& stack , People &people)//出栈
{
	LNode* peo = stack->next;
	people = peo->people;//取栈顶节点
	stack->next = peo->next;//头指针向原栈顶元素下一个元素
	free(peo);//释放原栈顶空间
	return true;
}
People getPop(linkStack stack)//读取栈顶元素
{
	People peo = stack->next->people;
	return peo;
}
bool destroy(linkStack& stack)//销毁空链栈
{
	if (stackEmpty(stack))
	{
		free(stack->next);
		free(stack);
		return true;
	}
	return false;
}
void printPeo(People peo)//输出people
{
	printf("name = %s\n", peo.name);
	printf("ID = %s\n", peo.ID);
	printf("-------------------------------\n");
}