栈的基本实现

一、栈的概念及结构

栈：一种特殊的线性表，其只允许在栈顶的一端进行插入和删除元素操作，另一端称为栈底。栈中的数据元素遵守后进先出的原则。

● 栈的实现可以由数组或者链表实现，相对而言数组的结构实现会更优一些，因为数组在尾上插入数据的代价较小。

二、栈的基本上实现

1.前期准备

了解栈的概念后，我们开始实现栈的基本操作了，首先我们准备好三个文件：
1.Stack.h :用来包含头文件和函数的声明
2.Stack.c :用来对函数的定义
3.test.c :用来实现函数，整体的逻辑

在Stack.h文件中，定义一个栈的的结构（动态增长）：

typedef int STDataType;

typedef struct Stack
{
	STDataType* data;
	int top; //记录当前栈的有效数据
	int capacity; //记录当前栈的总大小

}Stack;

2.入栈

首先判断栈是否为空，如果为空则增容，然后把x给给当前数组下标为top的位置，最后top加1；

//栈的规定，删除和插入只能在栈顶操作
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->data, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->data = tmp;
		ps->capacity = newCapacity;
	}

	ps->data[ps->top] = x;
	ps->top++;

}

3.出栈

栈是后进先出，所以出栈是从栈顶出，先判断栈是否为空，不为空则让top减1即可；

void StackPop(Stack* ps)
{
	assert(ps);
	//assert(ps->top > 0);
	assert(!StackEmpty(ps));
	ps->top--;
}

4.栈顶元素

先判断是否为空，不为空则返回数组data下标为top-1的元素；

STDataType StackTop(Stack* ps)
{
	assert(ps);
	//assert(ps->top > 0);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}

5.入栈顺序

从下标为0开始一直打印到下标为top减的位置即可；

void StackPrin(Stack* ps)
{
	assert(ps);
	printf("入栈顺序：");
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

6.全部出栈

先判断栈是否为空，不为空则打印出栈顶的元素，然后释放掉栈顶的位置，直到栈为空；

void StackAllPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	printf("出栈顺序：");
	while (!StackEmpty(ps))
	{
		printf("%d ", StackTop(ps));
		StackPop(ps);
	}
	printf("\n");
}

7.栈的个数

top是代表数组的下标，数组的下标是从0开始的，所以我们返回top的值就是数组的元素个数；

int StackSize(Stack* ps)
{
	assert(ps);

	//top指的是指向栈顶的下一个，因为下标是从0开始的，所以top就是size
	return ps->top; 
}

8.栈的销毁

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->top = 0;
}

9.栈的初始化

void StackInit(Stack* ps)
{
	assert(ps);

	ps->data = NULL;
	//top从0开始代表top指向栈顶数据的下一个，是先给值再加1
	//top从1开始代表top指向的是栈顶的数据，是先++再赋值
	ps->top = 0; //这里0和-1都可以
	ps->capacity = 0;
}

10.打印入栈顺序

从下标为0的位置开始直到 i < top

void StackPrin(Stack* ps)
{
	assert(ps);
	printf("入栈顺序：");
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

11.判断是否为空

top等于NULL则返回true，否则返回false

bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

12.功能展示

13.完整代码

Stack.h文件

#pragma once
#include
#include
#include
#include

typedef int STDataType;

typedef struct Stack
{
	STDataType* data;
	int top; //记录当前栈的有效数据
	int capacity; //记录当前栈的总大小

}Stack;

void StackInit(Stack* ps);

void StackDestroy(Stack* ps);

//栈的规定，删除和插入只能在栈顶操作
void StackPush(Stack* ps, STDataType x);
void StackPop(Stack* ps);

//取栈顶的数据
STDataType StackTop(Stack* ps);

//表示栈的数据个数
int StackSize(Stack* ps);

//判断栈是否为空，为空返回true，不为空返回false
bool StackEmpty(Stack* ps);

//全部出栈
void StackAllPop(Stack* ps);

void StackPrin(Stack* ps);

Stack.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void StackInit(Stack* ps)
{
	assert(ps);

	ps->data = NULL;
	ps->top = 0; //这里0和-1都可以
	ps->capacity = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->top = 0;
}

//栈的规定，删除和插入只能在栈顶操作
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->data, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->data = tmp;
		ps->capacity = newCapacity;
	}

	ps->data[ps->top] = x;
	ps->top++;

}
void StackPop(Stack* ps)
{
	assert(ps);
	//assert(ps->top > 0);
	assert(!StackEmpty(ps));
	ps->top--;
}

//取栈顶的数据
STDataType StackTop(Stack* ps)
{
	assert(ps);
	//assert(ps->top > 0);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}

//表示栈的数据个数
int StackSize(Stack* ps)
{
	assert(ps);

	//top指的是指向栈顶的下一个，因为下标是从0开始的，所以top就是size
	return ps->top; 
}

//判断栈是否为空，为空返回true，不为空返回false
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}


//全部出栈
void StackAllPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	printf("出栈顺序：");
	while (!StackEmpty(ps))
	{
		printf("%d ", StackTop(ps));
		StackPop(ps);
	}
	printf("\n");
}

void StackPrin(Stack* ps)
{
	assert(ps);
	printf("入栈顺序：");
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

test.c文件

void menu()
{
	printf("---------------------------------------------------------------------\n");
	printf(" 0.退出  1.入栈  2.出栈  3.栈顶元素  4.入栈顺序  5.全部出栈  6.栈的个数  \n");
	printf("---------------------------------------------------------------------\n");
}

int main()
{
	Stack st;
	StackInit(&st);
	int option = -1;
	while (option)
	{
		menu();
		printf("请输入你要执行的选项：");
		scanf("%d", &option);
		if (option == 1)
		{
			int num = 0;
			printf("请输入你要入栈的数字：");
			scanf("%d", &num);
			StackPush(&st, num);
		}
		else if (option == 2)
		{
			StackPop(&st);
		}
		else if (option == 3)
		{
			printf("栈顶元素是：%d\n", StackTop(&st));
		}
		else if (option == 4)
		{
			StackPrin(&st);
		}
		else if (option == 5)
		{
			StackAllPop(&st);
		}
		else if (option == 6)
		{
			printf("%d\n",StackSize(&st));
		}
		else if (option == 0)
		{
			StackDestroy(&st);
			printf("退出\n");
		}
		else
		{
			printf("无此选项\n");
		}
	}
	return 0;
}

完结！