DS--栈的概念及其接口的实现（顺序表）以及如何用两个栈来实现一个队列（C语言版）

栈的概念：
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

原则：后进先出（LIFO）

压栈：栈的插入操作叫做进栈，入数据在栈顶
出栈：栈的删除操作也叫做出栈，出数据也在栈顶

通过动态顺序表来实现栈的接口：
声明文件stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include<stdio.h>
#include<Windows.h>
#include<assert.h>
#define N 10
typedef int STDataType;

typedef struct Stack
{
	STDataType *_a;//指向动态开辟的数组
	int _top;//栈顶
	int _capacity;//容量
}Stack;

void StackInit(Stack *ps);//栈的初始化
void StackDestory(Stack *ps);//摧毁栈
void StackPush(Stack *ps, STDataType x);//栈的尾插操作（是一种先进后出的结构）
void StackPop(Stack *ps);//栈的尾删操作（是一种先进后出的结构）
STDataType StackTop(Stack *ps);//返回栈顶的值
void StackPrint(Stack *ps);//栈的打印
int StackEmpty(Stack *ps);
int StackSize(Stack *ps);

#endif

实现文件stack.c

#include"stack.h"


//栈的初始化
void StackInit(Stack *ps)
{
	assert(ps);
	ps->_capacity = N;
	ps->_a = (STDataType*)malloc(ps->_capacity*sizeof(STDataType));
	ps->_top = 0;
}

//摧毁栈
void StackDestory(Stack *ps)
{
	assert(ps);
	if (ps->_a)//防止重复释放
	{
		free(ps->_a);
		ps->_a = NULL;
		ps->_top = 0;
		ps->_capacity = 0;
	}
}


//栈的尾插操作（是一种先进后出的结构）
void StackPush(Stack *ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		ps->_capacity *= 2;
		ps->_a = (STDataType*)malloc(ps->_capacity*sizeof(STDataType));
		assert(ps->_a);
	}
	ps->_a[ps->_top] = x;
	ps->_top++;
}

//栈的尾删操作（是一种先进后出的结构）
void StackPop(Stack *ps)
{
	assert(ps);
	if (ps->_top > 0)
	{
		ps->_top--;
	}
}

//返回栈顶的值
STDataType StackTop(Stack *ps)
{
	assert(ps);
	return ps->_a[ps->_top-1];
}

//检查是否栈空
int StackEmpty(Stack *ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		return 0;//如果为空就返回0
	}
	else
	{
		return 1;//如果不为空就返回1
	}
}
//检查当前栈的大小
int StackSize(Stack *ps)
{
	return ps->_top;
}
//栈的打印
void StackPrint(Stack *ps)
{
	int i = 0;
	for (i = 0; i < ps->_top; i++)
	{
		printf("%d\n", ps->_a[i]);
	}
}

测试文件test.c

#include"stack.h"


int main()
{
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	StackPop(&ps);
	StackPop(&ps);
	StackPop(&ps);
	StackPrint(&ps);
	printf("%d\n", StackTop(&ps));
	StackDestory(&ps);

	system("pause");
	return 0;
}

栈的应用：

通过两个栈来实现队列
在做这个的时候，我们需要用到前面的接口，在接口中实现。
具体思路如下图：

其代码全部如下：

stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include<stdio.h>
#include<Windows.h>
#include<assert.h>
#define N 10
typedef int STDataType;

typedef struct Stack
{
	STDataType *_a;//指向动态开辟的数组
	int _top;//栈顶
	int _capacity;//容量
}Stack;


//用两个栈来实现一个队列，就是要让栈具备先进先出的特点，因此，我们需要有两个栈来实现
//定义一个instack栈，用于存入数据，定义一个outstack栈用于输出数据。我们将instack中的数据全部存入outstack中，再从outstack中出来就实现了队列的功能
typedef struct Queue
{
	Stack instack;
	Stack outstack;
}Queue;//我们将两个栈封装成一个队列



void My_Queue(Queue * qu);
void StackInit(Stack *ps);//栈的初始化
void StackDestory(Stack *ps);//摧毁栈
void StackPush(Stack *ps, STDataType x);//栈的尾插操作（是一种先进后出的结构）
void StackPop(Stack *ps);//栈的尾删操作（是一种先进后出的结构）
STDataType StackTop(Stack *ps);//返回栈顶的值
void StackPrint(Stack *ps);//栈的打印
int StackEmpty(Stack *ps);
int StackSize(Stack *ps);

#endif

stack.c

#include"stack.h"


//栈的初始化
void StackInit(Stack *ps)
{
	assert(ps);
	ps->_capacity = N;
	ps->_a = (STDataType*)malloc(ps->_capacity*sizeof(STDataType));
	ps->_top = 0;
}

//摧毁栈
void StackDestory(Stack *ps)
{
	assert(ps);
	if (ps->_a)//防止重复释放
	{
		free(ps->_a);
		ps->_a = NULL;
		ps->_top = 0;
		ps->_capacity = 0;
	}
}


//栈的尾插操作（是一种先进后出的结构）
void StackPush(Stack *ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		ps->_capacity *= 2;
		ps->_a = (STDataType*)malloc(ps->_capacity*sizeof(STDataType));
		assert(ps->_a);
	}
	ps->_a[ps->_top] = x;
	ps->_top++;
}

//栈的尾删操作（是一种先进后出的结构）
void StackPop(Stack *ps)
{
	assert(ps);
	if (ps->_top > 0)
	{
		ps->_top--;
	}
}

//返回栈顶的值
STDataType StackTop(Stack *ps)
{
	assert(ps);
	return ps->_a[ps->_top-1];
}

//检查是否栈空
int StackEmpty(Stack *ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		return 0;//如果为空就返回0
	}
	else
	{
		return 1;//如果不为空就返回1
	}
}
//检查当前栈的大小
int StackSize(Stack *ps)
{
	return ps->_top;
}
//栈的打印
void StackPrint(Stack *ps)
{
	int i = 0;
	for (i = 0; i < ps->_top; i++)
	{
		printf("%d\n", ps->_a[i]);
	}
}


void My_Queue(Queue * qu)
{
	StackInit(&qu->instack);
	StackInit(&qu->outstack);
	StackPush(&qu->instack, 1);
	StackPush(&qu->instack, 2);
	StackPush(&qu->instack, 3);
	if (StackEmpty(&qu->outstack) == 0)
	{
		while (StackEmpty(&qu->instack) != 0)
		{
			StackPush(&qu->outstack, StackTop(&qu->instack));
			//printf("%d\n", StackTop(&qu->outstack));
			StackPop(&qu->instack);
		}
	}
	if (StackEmpty(&qu->instack) == 0)
	{ 
		while (StackEmpty(&qu->outstack) != 0)
		{
		printf("%d\n", StackTop(&qu->outstack));
		StackPush(&qu->instack, StackTop(&qu->outstack));
		StackPop(&qu->outstack);
		}
	}
}

test.c

#include"stack.h"


int main()
{
	Queue qu;
	My_Queue(&qu);

	/*Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	StackPop(&ps);
	StackPop(&ps);
	StackPop(&ps);
	StackPrint(&ps);
	printf("%d\n", StackTop(&ps));
	StackDestory(&ps);*/

	system("pause");
	return 0;
}