数据结构 顺序栈和链栈的操作实现（C）

顺序栈的操作实现

1、顺序栈的头文件定义和函数声明

#ifndef SEQSTACK_H
#define SEQSTACK_H

//数组模拟栈的存储
#define MAX_SIZE 1024

#define SEQSTACK_TRUE 1
#define SEQSTACK_FALSE 0

typedef struct SEQSTACK
{
	void* data[MAX_SIZE];
	int size;
}SeqStack;

// 初始化栈
SeqStack* Init_SeqStack();

// 入栈操作
void Push_SeqStack(SeqStack* stack, void* data);

// 返回栈顶元素
void* Top_SeqStack(SeqStack* stack);

//出栈
void Pop_SeqStack(SeqStack* stack);

// 判断是否为空
int IsEmpty(SeqStack* stack);

//返回栈中元素个数
int Size_SeqStack(SeqStack* stack);

//清空栈
void Clear_SeqStack(SeqStack* stack);

// 销毁栈
void Free_SeqStack(SeqStack* stack);

#endif

2、顺序栈的函数实现

#define _CRT_SECURE_NO_WARNINGS
#include "SeqStack.h"
#include 
#include 
#include 

// 初始化栈
SeqStack* Init_SeqStack()
{
	SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));
	for (int i = 0; i < MAX_SIZE; i++)
	{
		stack->data[i] = NULL;
	}
	stack->size = 0;
	return stack;
}

// 入栈操作
void Push_SeqStack(SeqStack* stack, void* data)
{
	if (stack->size == MAX_SIZE)
	{
		return;
	}
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	stack->data[stack->size] = data;
	stack->size++;
}

// 返回栈顶元素
void* Top_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return NULL;
	}
	if (stack->size == 0)
	{
		return NULL;
	}
	return stack->data[stack->size - 1];
}

//出栈
void Pop_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	if (stack->size == 0)
	{
		return;
	}
	stack->data[stack->size - 1] = NULL; // 这句话写不写都可以
	stack->size--;
}

// 判断是否为空
int IsEmpty(SeqStack* stack)
{
	if (stack == NULL)
	{
		return -1;
	}
	if (stack->size == 0)
	{
		return SEQSTACK_TRUE;
	}
	return SEQSTACK_FALSE;
}

//返回栈中元素个数
int Size_SeqStack(SeqStack* stack)
{
	return stack->size;
}

//清空栈
void Clear_SeqStack(SeqStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	for (int i = 0; i < stack->size; i++)
	{
		stack->data[i] = NULL;
	}
	stack->size = 0;
}

// 销毁栈
void Free_SeqStack(SeqStack* stack)
{
	if (stack != NULL)
	{
		return;
	}
	free(stack);
}

3、栈的主函数实现

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include "SeqStack.h"

typedef struct PERSON
{
	char name[64];
	int age;
}Person;

int main()
{
	// 创建栈
	SeqStack* stack = Init_SeqStack();

	// 创建数据
	Person p1 = { "aaa", 10 };
	Person p2 = { "bbb", 20 };
	Person p3 = { "ccc", 30 };
	Person p4 = { "ddd", 40 };
	Person p5 = { "eee", 50 };

	// 入栈
	Push_SeqStack(stack, &p1);
	Push_SeqStack(stack, &p2);
	Push_SeqStack(stack, &p3);
	Push_SeqStack(stack, &p4);
	Push_SeqStack(stack, &p5);

	// 输出
	while (Size_SeqStack(stack))
	{
		// 访问栈顶元素
		Person* person = (Person*)Top_SeqStack(stack);
		printf("Name: %s, age: %d\n", person->name, person->age);
		Pop_SeqStack(stack);
	}

	// 释放内存
	Free_SeqStack(stack);

	system("pause");
	return 0;
}

/*
Name: eee, age: 50
Name: ddd, age: 40
Name: ccc, age: 30
Name: bbb, age: 20
Name: aaa, age: 10
请按任意键继续. . .
*/

链式栈操作实现

1、链栈的头文件和函数声明

#ifndef LINKSTACK_H
#define LINKSTACK_H
// 链式栈的结点
typedef struct LINKNODE
{
	struct LINKNODE * next;
}LinkNode;

// 链式栈
typedef struct LINKSTACK
{
	LinkNode head;
	int size;
}LinkStack;


// 初始化函数
LinkStack* Init_LinkStack();

// 入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);

//出栈
void Pop_LinkStack(LinkStack* stack);

//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);

//返回栈元素的个数
int Size_LinkStack(LinkStack* stack);

// 清空栈
void Clear_LinkStack(LinkStack* stack);

// 销毁栈
void Free_LinkStack(LinkStack* stack);

#endif

2、链栈的函数实现

// 初始化函数
LinkStack* Init_LinkStack()
{
	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
	stack->head.next = NULL;
	stack->size = 0;
	return stack;
}

// 入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data)
{
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	data->next = stack->head.next; // 头插法
	stack->head.next = data;
	stack->size++;
}

//出栈
void Pop_LinkStack(LinkStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	if (stack->size == 0)
	{
		return;
	}
	LinkNode* pNext = stack->head.next;
	stack->head.next = pNext->next;
	stack->size--;
}
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack)
{
	if (stack == NULL)
	{
		return NULL;
	}
	if (stack->size == 0)
	{
		return NULL;
	}
	return stack->head.next;
}

//返回栈元素的个数
int Size_LinkStack(LinkStack* stack)
{
	if (stack == NULL)
	{
		return 0;
	}
	return stack->size;
}

// 清空栈
void Clear_LinkStack(LinkStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	stack->head.next = NULL;
	stack->size = 0;
}

// 销毁栈
void Free_LinkStack(LinkStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	free(stack);
}

3、链栈的主函数实现

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include "LinkStack.h"

typedef struct PERSON
{
	LinkNode node;
	char name[64];
	int age;
}Person;

int main()
{
	// 创建
	LinkStack* stack = Init_LinkStack();
	
	//创建数据
	Person p1, p2, p3, p4, p5;

	strcpy(p1.name, "aaa");
	strcpy(p2.name, "bbb");
	strcpy(p3.name, "ccc");
	strcpy(p4.name, "ddd");
	strcpy(p5.name, "eee");

	p1.age = 20;
	p2.age = 30;
	p3.age = 40;
	p4.age = 50;
	p5.age = 60;

	//入栈
	Push_LinkStack(stack, (LinkNode*)&p1);
	Push_LinkStack(stack, (LinkNode*)&p2);
	Push_LinkStack(stack, (LinkNode*)&p3);
	Push_LinkStack(stack, (LinkNode*)&p4);
	Push_LinkStack(stack, (LinkNode*)&p5);

	// 输出
	while (Size_LinkStack(stack))
	{
		Person* person = (Person*)Top_LinkStack(stack);
		printf("Name: %s, age: %d\n", person->name, person->age);
		Pop_LinkStack(stack);
	}
	Free_LinkStack(stack);

	system("pause");
	return 0;
}

/*
Name: eee, age: 60
Name: ddd, age: 50
Name: ccc, age: 40
Name: bbb, age: 30
Name: aaa, age: 20
请按任意键继续. . .
*/