数据结构 深入理解栈和队列的实现

数据结构就是定义出某种结构：像数组结构、链表结构、树形结构等，实现数据结构就是我们主动去管理增删查改的实现函数

栈的概念及实现

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，入数据在栈顶，出数据也在栈顶

在编程实现之前，我们先看下栈入数据在栈顶，出数据也在栈顶的图形界面

下面编程实现数组栈的使用，在头文件 Stack.h 进行声明，在 Stack.c 当中进行具体的函数定义，在 test.c 当中的做具体的测试实现

先来了解一下头文件 Stack.h 当中接口

#pragma once//防止重复使用
#include<stdio.h>
#include<stdlib.h>//开内存需要头文件
#include<stdbool.h>//bool判断
#include<assert.h>//断言头文件

//typedef 下方指针申请类型，之后想换可以将int改成double、char等
typedef int STDateType;

typedef struct Stack
{
 STDateType* a;//指向动态开辟的数组
 int top;//栈顶的位置
 int capacity;//记录存储空间容量
}Stack;

//函数声明 
void StackInit(Stack* ps);//初始化
void StackDestroy(Stack* ps);//置空函数，释放空间
void StackPush(Stack* ps, STDateType x);//栈顶插入
void StackPop(Stack*);//栈顶删除数据
bool StackEmpty(Stack*);//判断栈是否为空
int StackSize(Stack*);//栈的数据大小
STDateType StackTop(Stack* ps);//取栈顶数据

我们知道，函数的定义方法是非常重要的，也是我们需要深入理解的，下面我们详细学习在 Stack.c 当中具体的函数实现

初始化函数定义

void StackInit(Stack* ps)//初始化
{
assert(ps);
ps->a = NULL;
ps->top = 0;//给0是top指向栈顶数据的下一个
//ps->top = -1; 给-1是top指向栈顶数据
ps->capacity = 0;
}

置空函数定义

置空函数一般会放在我们进行插入或删除的函数最后，释放我们在堆上申请的空间，将其还给操作系统，另外也会相应的进行检查越界等问题

void StackDestroy(Stack* ps)
{
//开辟空间需要置空，使用该函数
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}

栈顶插入函数

void StackPush(Stack* ps, STDateType x)//入栈函数
 //想清楚在前面初始化中top标识的是什么
{
 assert(ps);
 //满了扩容
if (ps->top == ps->capacity)
{
 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
 STDateType* tmp = 
 (STDateType*)realloc(ps->a, newcapacity * sizeof(STDateType));
if (tmp == NULL)
{
 printf("realloc fial\n");
 exit(-1);//异常退出，直接终止
}
 //到这里开空间成功
 ps->a = tmp;//把空间给a
 ps->capacity = newcapacity;//空间容量更新
}	
 ps->a[ps->top] = x;//先将数据放到top位置
 ps->top++;
} 

判断数据为空函数

bool StackEmpty(Stack* ps)//判断栈是否为空
{
assert(ps);
return ps->top == 0;
//注意top的初始化
}

栈顶删除函数

void StackPop(Stack* ps)//删除数据
{
assert(ps);
assert(!StackEmpty(ps));//判断不为空
//assert(ps->top > 0);//判断不为空
ps->top--;
}

栈的数据大小

//栈的数据大小 栈顶的下一个就是size 
//top就是
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}

取栈顶数据

STDateType StackTop(Stack* ps)//取栈顶数据
{
assert(ps);
assert(!StackEmpty(ps));//判断不为空
//assert(ps->top > 0);//判断不为空
return ps->a[ps->top - 1];
}

我们用上面接口实现一个在 test.c 当中的测试案例 TestStack 1

void TestStack1()//后进先出
{
 Stack st;
 StackInit(&st);
 StackPush(&st, 1);//入栈 1 2 3 
 StackPush(&st, 2);
 StackPush(&st, 3);

 printf("%d ", StackTop(&st));//出3
 StackPop(&st);

 printf("%d ", StackTop(&st));//出2
 StackPop(&st);

 printf("<-出3 2\n");
 StackPush(&st, 4);//在有1的基础上入4 5 6
 StackPush(&st, 5);
 StackPush(&st, 6);
	
 //注意不能随便遍历 要保证后进先出
 while(!StackEmpty(&st))
 {
  printf("%d ", StackTop(&st));//此时打印6 5 4 1
  StackPop(&st);
 }
 printf("\n");

 StackDestroy(&st);//置空函数，放在最后
}
int main()
{
 TestStack1();
 return 0;
}

队列的概念及实现

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队尾入数据，队头出数据

下面编程实现链式队列的使用，在头文件 Queue.h 进行声明，在 Queue.c 当中进行具体的函数定义，在 test.c 当中的做具体的测试实现

在编程实现之前，我们要先理解下队列，队尾入，队头出的图形界面

先来了解一下头文件 Queue.h 当中接口

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//链式实现队列

typedef int QDataType;

typedef struct QueueNode//定义节点 
{
 struct QueueNode* next;
 QDataType data;
}QueueNode;

//不带头 
typedef struct Queue
{
 QueueNode* head;//定义头指针
 QueueNode* tail;//定义尾指针
}Queue;

//函数声明
void QueueInit(Queue* ps);//初始化 
void QueueDestroy(Queue* ps);//置空函数 
void QueuePush(Queue* ps,QDataType x);//队尾入数据
void QueuePop(Queue* ps);//队头出数据 删除数据 链表头删
QDataType QueueFront(Queue* ps);//取队头数据
QDataType QueueBack(Queue* ps); //取队尾数据
int QueueSize(Queue* ps); //数据的个数
bool QueueEmpty(Queue* ps);//判断是否为空

下面接着详细学习在 Queue.c 当中具体的函数实现

初始化函数定义

void QueueInit(Queue* ps)//初始化
{
//不带头
assert(ps);
ps->head = NULL;
ps->tail = NULL;
}

置空函数定义

置空函数一般会放在我们进行插入或删除的函数最后，释放我们在堆上申请的空间，将其还给操作系统，另外也会相应的进行检查越界等问题

void QueueDestroy(Queue* ps)//置空函数
{
assert(ps);
QueueNode* cur = ps->head;
while (cur != NULL)//等于空就结束
 {
 //删除当前位置，先保存下一个
 QueueNode* next = cur->next;
 free(cur);
 cur = next;
 }
 ps->head = ps->tail = NULL;
}

队尾入数据

void QueuePush(Queue* ps, QDataType x)//队尾入数据
{
assert(ps);
QueueNode* newnode =(QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
 {
  printf("malloc fail\n");
  exit(-1);
 }
 newnode->data = x;
 newnode->next = NULL;

if (ps->tail == NULL)
 {
  ps->head = ps->tail = newnode;
 }
else
 {
  ps->tail->next = newnode;
  ps->tail = newnode;
 }	
}

判断是否为空

bool QueueEmpty(Queue* ps)//判断是否为空
{
assert(ps);	
return ps->head = NULL;
}

队头出数据

//注意head指向空了但是tail是野指针的问题 
void QueuePop(Queue* ps)//队头出数据 删除数据
{
assert(ps);
assert(!QueueEmpty(ps));
if (ps->head->next == NULL)
 {
  free(ps->head);
  ps->head = ps->tail=NULL;
 }
else
 {
  QueueNode* next = ps->head->next;
  free(ps->head);
  ps->head = next;
 }	
}

取队头数据函数定义

QDataType QueueFront(Queue* ps)//取队头数据
{
 assert(ps);
 // assert(ps->head);
 assert(!QueueEmpty(ps));
 return ps->head->data;
}

取队尾数据函数定义

QDataType QueueBack(Queue* ps) //取队尾数据
{
 assert(ps);
 assert(!QueueEmpty(ps));
 return ps->tail->data;
}

数据的个数函数定义

int QueueSize(Queue* ps)//数据的个数
{
assert(ps);
int n = 0;
QueueNode* cur = ps->head;
while (cur)
{
 ++n;
 cur = cur->next;
}
 return n;
}

我们用上面接口实现一个在 test.c 当中的测试案例 TestQueue1 

void TestQueue1()
{
 Queue q;
 QueueInit(&q);
 QueuePush(&q, 1);
 QueuePush(&q, 2);
 QueuePush(&q, 3);
 QueuePush(&q, 4);
 //先进先出
 while (!QueueEmpty(&q))
 {
   QDataType front = QueueFront(&q);
   printf("%d ", front);
   QueuePop(&q);
 }
  printf("\n");
  QueueDestroy(&q);//置空函数放在最后
}

int main()
{
  TestQueue1();
  return 0;
}

在Java和C++的学习当中，前期学习数据结构当中的顺序表、链表、栈和队列等便于我们后面更好的学习容器，后面会继续分享二叉树和算法的实现

希望这篇文章大家有所收获，我们下篇见