（数据结构初阶）栈和队列
目录
一 栈
1.栈的基本概念
2.栈的核心接口代码实现
3.栈的代码实现（完整）
二 队列
1.队列的基本概念
2.队列核心接口的实现
3.队列的实现（全部）
一 栈
1.栈的基本概念
（1）栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
（2）压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
（3）出栈：栈的删除操作叫做出栈。出数据也在栈顶。
（4）栈的实现:一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
2.栈的核心接口代码实现
（1）基本结构
typedef int STDateType;
struct Stack
{
STDateType* a;
int top; //栈顶
int capacity; //容量
};
//typedef struct Stack ST;
typedef struct Stack Stack;（2）初始化
//初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (STDateType*)malloc(sizeof(STDateType)*4);
pst->top = 0;
pst->capacity = 4;
}（3）销毁
//销毁
void StackDestroy(Stack* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->capacity = pst->top = 0;
}（4）入栈
//压栈（性质就决定了在栈顶出入数据）
void StackPush(Stack* pst, STDateType x)
{
assert(pst);
if (pst->capacity == pst->top)
{
STDateType* temp = realloc(pst->a,sizeof(STDateType)*pst->capacity*2);
if (NULL == temp)
{
printf("realloc fail \n");
exit(-1);
}
pst->a = temp;
pst->capacity *= 2;
}
pst->a[pst->top] = x;
pst->top++;
}（5）出栈
//弹栈
void StackPop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
pst->top--;
}（6）取栈顶位置数据
//取数据
STDateType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}（7）判断栈是否为空
//空返回1，非空返回0
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0;
}（8）求栈的长度
//求栈的长度
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}3.栈的代码实现（完整）
（1）stack.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
#include
typedef int STDateType;
struct Stack
{
STDateType* a;
int top; //栈顶
int capacity; //容量
};
//typedef struct Stack ST;
typedef struct Stack Stack;
void StackInit(Stack* pst); //初始化
void StackDestroy(Stack* pst);//销毁
//性质就决定了在栈顶出入数据
void StackPush(Stack* pst, STDateType x);//压栈
void StackPop(Stack* pst);//弹栈
STDateType StackTop(Stack* pst);//取数据
//空返回1，非空返回0
bool StackEmpty(Stack* pst);
int StackSize(Stack* pst); //求栈的容量 （2）stack.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
//初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (STDateType*)malloc(sizeof(STDateType)*4);
pst->top = 0;
pst->capacity = 4;
}
//销毁
void StackDestroy(Stack* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->capacity = pst->top = 0;
}
//压栈（性质就决定了在栈顶出入数据）
void StackPush(Stack* pst, STDateType x)
{
assert(pst);
if (pst->capacity == pst->top)
{
STDateType* temp = realloc(pst->a,sizeof(STDateType)*pst->capacity*2);
if (NULL == temp)
{
printf("realloc fail \n");
exit(-1);
}
pst->a = temp;
pst->capacity *= 2;
}
pst->a[pst->top] = x;
pst->top++;
}
//弹栈
void StackPop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
pst->top--;
}
//取数据
STDateType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}
//空返回1，非空返回0
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0;
}
//求栈的长度
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
（3）test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
void test()
{
Stack st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
StackPush(&st, 5);
while (!StackEmpty(&st))
{
printf("%d ", StackTop(&st));
StackPop(&st);
}
StackDestroy(&st);
}
int main()
{
test();
return 0;
}二 队列
1.队列的基本概念
(1)队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 。入队列：进行插入操作的一端称为队尾 。出队列：进行删除操作的一端称为队头
(2)队列的实现：队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
2.队列核心接口的实现
（1）队列的结构
typedef int QDateType;
typedef struct QueueNode
{
struct QueueNode* next;
QDateType date;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;（2）初始化
//初始化
void QueueInit(Queue* pq)
{
pq->head = pq->tail = NULL;
}（3）销毁
//销毁
void QueueDestroy(Queue* pq)
{
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}（4）入队
//入队
void QueuePush(Queue* pq, QDateType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (NULL == newnode)
{
printf("malloc fail\n");
exit(-1);
}
newnode->date = x;
newnode->next = NULL;
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}（5）出队
//出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
if (NULL == pq->head->next)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}（6）取队头数据
//取队头数据
QDateType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->date;
}（7）取队尾数据
//取队尾数据
QDateType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->date;
}（8）判断队列是否为空
//空返回 false 不为空返回 true
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}（9）队列长度
//队列长度
int Queuesize(Queue* pq)
{
int size = 0;
QueueNode* cur = pq->head;
while(cur)
{
size++;
cur = cur->next;
}
return size;
}3.队列的实现（全部）
（1）queue.h
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
typedef int QDateType;
typedef struct QueueNode
{
struct QueueNode* next;
QDateType date;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDateType x);
void QueuePop(Queue* pq);
QDateType QueueFront(Queue* pq);
QDateType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int Queuesize(Queue* pq); （2）queue.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"queue.h"
//初始化
void QueueInit(Queue* pq)
{
pq->head = pq->tail = NULL;
}
//销毁
void QueueDestroy(Queue* pq)
{
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
//入队
void QueuePush(Queue* pq, QDateType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (NULL == newnode)
{
printf("malloc fail\n");
exit(-1);
}
newnode->date = x;
newnode->next = NULL;
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
//出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
if (NULL == pq->head->next)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
//取队头数据
QDateType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->date;
}
//取队尾数据
QDateType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->date;
}
//空返回 false 不为空返回 true
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
//队列长度
int Queuesize(Queue* pq)
{
int size = 0;
QueueNode* cur = pq->head;
while(cur)
{
size++;
cur = cur->next;
}
return size;
}
（3）test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"queue.h"
void text()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
printf("\n");
QueueDestroy(&q);
}
int main()
{
text();
return 0;
}