table des matières:
1. Présentation de la pile
1. La définition de la pile
Pile : Une table linéaire spéciale qui permet uniquement d'insérer et de supprimer des éléments à une extrémité fixe. Une extrémité des opérations d'insertion et de suppression de données est appelée le haut de la pile et l'autre extrémité est appelée le bas de la pile . Les éléments de données de la pile sont conformes au principe LIFO (Last In First Out)
• Push : L'opération d'insertion de la pile est appelée push / push , et les données sont placées sur le dessus de la pile.
• Pop : l'opération de suppression de la pile est appelée pop. Les données de sortie sont également sur le dessus de la pile.
2. Schéma de principe de la pile et de la structure pop
Forme de tableau:
structure en chaîne:
Selon la figure, les deux opérations sont effectuées en haut
3. Implémentation de la pile (le tableau est recommandé)
(1) Gestion et interface de la pile Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;//动态数组
int top; //栈顶
int capacity; //容量
}Stack;
//初始化栈
void StackInit(Stack* pst);
//销毁栈
void StackDestroy(Stack* pst);
//入栈
void StackPush(Stack* pst, STDataType data);
//出栈
void StackPop(Stack* pst);
//获取栈中有效元素的个数
int StackSize(Stack* pst);
//获取栈顶元素
STDataType StackTop(Stack* pst);
//检测栈是否为空，为空返回1，非空返回0
int StackEmpty(Stack* pst);
(2) La réalisation de chaque fonction d'interface de la pile Stack.c
#include"Stack.h"
//初始化栈
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (STDataType*)malloc(sizeof(STDataType)* 4);
if (pst->a == NULL)
{
printf("malloc fail");
}
pst->top = 0;
pst->capacity = 4;
}
//销毁栈
void StackDestroy(Stack* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = 0;
pst->capacity = 0;
}
//入栈
void StackPush(Stack* pst, STDataType data)
{
assert(pst);
//空间不够需要增容
if (pst->top == pst->capacity)
{
//增容为原来的2倍
int* tem = (STDataType*)realloc(pst->a, sizeof(STDataType)* pst->capacity * 2);
if (tem == NULL)
{
printf("realloc fail");
exit(-1);
}
pst->a = tem;
pst->capacity = pst->capacity * 2;
}
pst->a[pst->top] = data;
pst->top++;
}
//出栈
void StackPop(Stack* pst)
{
assert(pst);
//判断栈是否为空
//相当于assert(pst->top != 0);
assert(!StackEmpty(pst));
pst->top--;
}
//获取栈中有效元素的个数
int StackSize(Stack* pst)
{
assert(pst);
//因为初始化top是0,如果初始化top是-1则返回top+1;
return pst->top;
}
//获取栈顶元素
STDataType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}
//检测栈是否为空，为空返回1，非空返回0
int StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0 ? 1 : 0;
}
(3) test test.c
#include"Stack.h"
void test()
{
//定义一个栈
Stack st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
while (!StackEmpty(&st))
{
//取一个删一个
printf("%d ", StackTop(&st));
StackPop(&st);
}
StackDestroy(&st);
printf("\n");
}
int main()
{
test();
return 0;
}
2. Présentation de la file d'attente
1. Définition de la file d'attente
File d'attente : table linéaire spéciale qui permet uniquement d' insérer des données à une extrémité et de supprimer des données à l' autre extrémité . La file d'attente suit le principe du FIFO (premier entré, premier sorti)
• Dans la file d'attente : la fin de l'opération d'insertion est appelée la fin
de la file d'attente • Hors de la file d'attente : la fin de l'opération de suppression est appelée la tête de la file d'attente
2. Implémentation de la file d'attente (il est recommandé d'utiliser une liste chaînée)
(1) Gestion et interface de file d'attente Queue.h
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int QDatatype;
//链式结构：表示队列
typedef struct QueueNode
{
QDatatype data;
//指向下一个节点的指针
struct QueueNode* next;
}QueueNode;
//队列的结构
typedef struct Queue
{
QueueNode* front;//头指针
QueueNode* tail;//尾指针
}Queue;
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDatatype x);
//队头出队列
void QueuePop(Queue* pq);
//检测队列是否为空，为空返回1，非空返回0
int QueueEmpty(Queue* pq);
//获取队列中有效元素的个数
int QueueSize(Queue* pq);
//获取队列头部元素
QDatatype QueueFront(Queue* pq);
//获取队列队尾元素
QDatatype QueueBack(Queue* pq);
(2) Queue.c implémentation des différentes fonctions d'interface de la file d'attente
#include"Queue.h"
//初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->front = pq->tail = NULL;
}
//销毁队列
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->front;
while (cur)
{
QueueNode* Next = cur->next;
free(cur);
cur = Next;
}
pq->front = pq->tail = NULL;
}
//队尾入队列
void QueuePush(Queue* pq, QDatatype x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
newnode->data = x;
newnode->next = NULL;
if (pq->tail == NULL)
{
pq->front = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
//队头出队列
void QueuePop(Queue* pq)
{
assert(pq);
//队列不能为空
assert(!QueueEmpty(pq));
//如果只有一个节点，防止tail野指针
if (pq->front == pq->tail)
{
free(pq->front);
pq->front = pq->tail = NULL;
}
//多个节点
else
{
QueueNode* Next = pq->front->next;
free(pq->front);
pq->front = Next;
}
}
//检测队列是否为空，为空返回1，非空返回0
int QueueEmpty(Queue* pq)
{
assert(pq);
return pq->front == NULL ? 1 : 0;
}
//获取队列中有效元素的个数
int QueueSize(Queue* pq)
{
assert(pq);
int count = 0;
QueueNode* cur = pq->front;
while (cur)
{
++count;
cur = cur->next;
}
return count;
}
//获取队列头部元素
QDatatype QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->front->data;
}
//获取队列队尾元素
QDatatype QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
(3) test test.c
#include"Queue.h"
void TestQueue()
{
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()
{
TestQueue();
return 0;
}
