栈、队列和表数据结构特点的实现

---

前言

本期和大家分享的是栈、队列以及表的特点以及其数据结构的具体是实现过程，这几种数据结构在工程应用中极其广泛，所以必须理解其本质以及每个数据结构之间的区别以及联系；下面就来具体看一下吧！

一、栈、队列和表之间的区别？

栈、队列和表的区别:
	(1)表允许操作结构中任意一个元素；
	(2)栈、队列是一种特殊的表状结构,只允许访问表两端的元素；

二 、栈

1.基本概念

	(1)栈顶:允许入栈出栈的一端称为栈顶
	(2)栈底:不允许入栈出栈的一端称为栈底
	(3)入栈:数据放入栈中
	(4)出栈:从栈中取出数据

栈的特点：先进后出、后进先出	FILO


满栈：指针指向有内容的地址。因此，进栈是先移动指针再存；出栈是先出数据再移动指针

空栈：指针指向没有内容的地址。因此，进栈是先存再移动指针；出栈是先移动指针再出数据

减栈：指针向地址减小的方向移动。因此，进栈指针向下移动；出栈是指针向上移动

增栈：指针向地址增加的方向移动。因此，进栈指针向上移动；出栈是指针向下移动

满减栈：指针一开始指向有内容的地址，进栈先向下移动指针后再将内容存进去，出栈先移动数据再向上移动指针。
满增栈：指针一开始指向有内容的地址，进栈先向上移动指针后再将内容存进去，出栈先移动数据再向下移动指针。
空减栈：指针一开始指向没有内容的地址，进栈先将内容存进去后再向下移动指针，出栈先向上移动指针再移动数据。
空增栈：指针一开始指向没有内容的地址，进栈先将内容存进去后再向上移动指针，出栈先向下移动指针再移动数据。

2.顺序栈

顺序栈的实现如下：
还是先来介绍一下数据结构的定义：
理解顺序栈呢，首先必须理解顺序表，顺序表的存储结构是连续的，所以顺序栈的存储方式也是连续的，其实就是在数组存储的基础上加上了栈先进后出的逻辑顺序；

#ifndef __SEQSTACK_H__
#define __SEQSTACK_H__

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

typedef int DataType;

typedef struct stack 
{
	DataType *pData;
	int Top;
	int tLen;
}SeqStack;

extern SeqStack *CreateSeqStack(int MaxLen);
extern int IsEmptySeqStack(SeqStack *pTmpStack);
extern int IsFullSeqStack(SeqStack *pTmpStack);
extern int PushSeqStack(SeqStack *pTmpStack, DataType TmpData);
extern DataType PopSeqStack(SeqStack *pTmpStack);
extern int DestroySeqStack(SeqStack **ppTmpStack);

#endif

具体的代码实现过程：

#include "seqstack.h"
/* 创建一个顺序栈 */
SeqStack *CreateSeqStack(int MaxLen)
{
	SeqStack *pTmpStack = NULL;

	pTmpStack = malloc(sizeof(SeqStack));
	if (NULL == pTmpStack)
	{
		perror("fail to malloc");
		return NULL;
	}

	pTmpStack->Top = 0;
	pTmpStack->tLen = MaxLen;								//栈的总容量
	pTmpStack->pData = malloc(sizeof(DataType) * MaxLen);	//可以和顺序表空间申请对比一下(完全一致)
	if (NULL == pTmpStack->pData)
	{
		perror("fail to malloc");
		return NULL;
	}
	
	return pTmpStack;
}

/* 判断栈是否为空 */
int IsEmptySeqStack(SeqStack *pTmpStack)
{
	return pTmpStack->Top == 0 ? 1 : 0;
}

/* 判断栈是否为满 */
int IsFullSeqStack(SeqStack *pTmpStack)
{
	return pTmpStack->Top == pTmpStack->tLen ? 1 : 0;
}

/* 压栈 */
int PushSeqStack(SeqStack *pTmpStack, DataType TmpData)
{
	if (IsFullSeqStack(pTmpStack))
	{
		return -1;
	}

	pTmpStack->pData[pTmpStack->Top] = TmpData;
	pTmpStack->Top++;

	return 0;
}

/* 出栈 */
DataType PopSeqStack(SeqStack *pTmpStack)
{
	if (IsEmptySeqStack(pTmpStack))
	{
		return -1;
	}

	pTmpStack->Top--;
	return pTmpStack->pData[pTmpStack->Top];
}

/* 销毁栈空间 */
int DestroySeqStack(SeqStack **ppTmpStack)
{
	free((*ppTmpStack)->pData);
	free(*ppTmpStack);
	*ppTmpStack = NULL;

	return 0;
}

3.链式栈

链式栈就是通过链表来实现一个栈的操作；栈的结构是先进后出，所以可以使用尾插法将数据入栈(压栈)，然后在头节点处可以进行出栈操作，从而实现一个链式栈的结构；链式栈的原理是建立在链表的原理上的，所以存储方式是通过链表来存储的；
链式栈的实现过程如下：
头文件：

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__

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

typedef int DataType;		//存储的数据类型

typedef struct node			//存储数据节点的类型 
{
	DataType Data;
	struct node *pNext;

}StackNode;

typedef struct stack		//栈头
{
	StackNode *pHead;		//管理整个栈的头指针
	int cLen;				//当前长度
	int tLen;				//最大长度

}LinkStack;

extern LinkStack *CreateLinkStack(int MaxLen);
extern int IsEmptyLinkStack(LinkStack *pTmpStack);
extern int IsFullLinkStack(LinkStack *pTmpStack);
extern int PushLinkStack(LinkStack *pTmpStack, DataType TmpData);
extern DataType PopLinkStack(LinkStack *pTmpStack);
extern int DeatroyLinkStack(LinkStack **pTmpStack);

#endif

具体实现过程：

#include "linkstack.h"
/* 创建一个链式栈 */
LinkStack *CreateLinkStack(int MaxLen)
{
	LinkStack *pTmp = NULL;

	pTmp = malloc(sizeof(LinkStack));
	if (NULL == pTmp)
	{
		perror("fail to malloc");
		return NULL;
	}

	pTmp->pHead = malloc(sizeof(StackNode) * MaxLen);
	if (NULL == pTmp->pHead)
	{
		perror("fail to malloc");
		return NULL;
	}

	pTmp->pHead->pNext = NULL;
	pTmp->cLen = 0;
	pTmp->tLen = MaxLen;

	return pTmp;
}

/* 判断栈是否为空 */
int IsEmptyLinkStack(LinkStack *pTmpStack)
{
	return pTmpStack->cLen == 0;
}

/* 判断栈是否为满 */
int IsFullLinkStack(LinkStack *pTmpStack)
{
	return pTmpStack->cLen == pTmpStack->tLen; 
}

/* 压栈 */
int PushLinkStack(LinkStack *pTmpStack, DataType TmpData)
{
	if (IsFullLinkStack(pTmpStack))
	{
		printf("栈区空间已满\n");
		return -1;
	}
	StackNode *pTmpNode = NULL;

	pTmpNode = malloc(sizeof(LinkStack));
	if (NULL == pTmpNode)
	{
		perror("fail to malloc");
	}

	pTmpNode->Data = TmpData;
	pTmpNode->pNext = pTmpStack->pHead->pNext;
	pTmpStack->pHead->pNext = pTmpNode;
	pTmpStack->cLen++;
	
	return 0;
}

/* 出栈 */
DataType PopLinkStack(LinkStack *pTmpStack)
{
	if (IsEmptyLinkStack(pTmpStack))
	{
		printf("栈区空间已空\n");
	}
	StackNode *pTmpNode = NULL;
	DataType TmpData;

	pTmpNode = pTmpStack->pHead->pNext;
	pTmpStack->pHead->pNext = pTmpNode->pNext;
	pTmpStack->cLen--;
	TmpData = pTmpNode->Data;
	free(pTmpNode);

	return TmpData;
}

/* 释放栈区空间(销毁栈区) */
int DeatroyLinkStack(LinkStack **pTmpStack)
{
	StackNode *pTmpNode = NULL;
	StackNode *pFreeNode = NULL;

	pTmpNode = (*pTmpStack)->pHead;
	pFreeNode = pTmpNode;

	while (pTmpNode != NULL)
	{
		pTmpNode = pTmpNode->pNext;
		free(pFreeNode);
		pFreeNode = pTmpNode;
	}

	free(*pTmpStack);
	*pTmpStack = NULL;

	return 0;
}

---

总结

本期和大家主要分享的栈的基本概念；在学习了顺序表和链式表的基础上，将顺序表和链式表的数据结构套用在栈中，以此实现了顺序栈和链式栈，是两种不同方式实现的栈的这种数据结构；顺序栈的缺点是插入元素的个数是有限的，但是链式栈继承了链表的优势，在理论上来讲它的数据存储个数是无限的（只要系统空间够用）；本期的分享就到这里结束啦，希望小伙伴们练习起来哦！
最后，各位小伙伴们如果喜欢我的分享可以点赞收藏哦，你们的认可是我创作的动力，一起加油！