Table des matières
1.1 Le concept et la structure de la pile
3. Mise en place de l'interface
3.4 Obtenir l'élément supérieur de la pile
3.5 Obtenir le nombre d'éléments effectifs dans la pile
3.6.1 interface de type booléen
1. pile
1.1 Le concept et la structure de la pile
Pile : une liste linéaire spéciale qui permet uniquement l'insertion et la suppression d'éléments à une extrémité fixe. Une extrémité où les opérations d'insertion et de suppression de données sont effectué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 dans la pile suivent le principe de LIFO (Last In First Out).
Pousser la pile : L'opération d'insertion de la pile s'appelle pousser/pousser/pousser, et les données entrantes se trouvent en haut de la pile .
Popping : L'opération de suppression de la pile est appelée popping. Les données de sortie sont également en haut de la pile .
Comprenons la pile avec les choses de la vie : les haws confits
Lors de l'enfilage des haws confits, le dernier haws confit entre en premier, mais le premier que nous mangeons est le dernier.
2. Mise en place de la pile
L'implémentation de la pile peut généralement être implémentée à l'aide d'un tableau ou d'une liste chaînée .. Relativement parlant, la structure du tableau est meilleure. Parce que le coût d'insertion des données à la fin du tableau
est relativement faible. Dans cet article, nous utilisons des tableaux pour implémenter des piles.
2.1 Interface
#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* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);3. Mise en place de l'interface
3.1 Initialisation
Notre pile commence vide, donc la capacité et le haut de la pile sont attribués à 0.
Nous pouvons également affecter le haut de la pile à -1. Lorsque vous poussez la pile, laissez d'abord le pointeur du haut ++, puis poussez l'élément sur la pile, de sorte que le pointeur du haut de la pile pointe juste vers l'élément du haut de la pile. Mais ici, nous attribuons toujours le pointeur supérieur de la pile à 0, de sorte qu'il n'est pas nécessaire d'opérer lors de l'obtention d'éléments valides dans la pile, ce qui est pratique pour plus tard.
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
//ps->top = -1;//top 指栈顶数据
ps->top = 0;//top 指栈顶数据的下一个位置
ps->capacity = 0;
}3.2 Pousser/Pousser
Avant de pousser dans la pile, nous devons d'abord déterminer si la pile est pleine, et si elle est pleine, nous allons étendre la nature avancée de la pile. Nous n'avons pas démarré l'espace malloc en premier, mais avons utilisé realloc pour la première fois. Il y a une astuce ici, qui consiste à utiliser l'opérateur ternaire pour vérifier si la capacité est 0. Si c'est 0, cela signifie que c'est la première fois pour ouvrir un espace, attribuez une valeur de 4 à newcapacity, si ce n'est pas 0, cela signifie une expansion, puis augmentez la nouvelle capacité à deux fois la capacité précédente.
Une fois que le jugement est complet, nous le poussons dans la pile. Il s'agit en fait de mettre des éléments dans le tableau, de placer un élément en haut de la pile et de laisser ps->top++ prendre du recul.
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
if (ps->capacity == ps->top)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail:");
return;
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = data;
ps->top++;
}3.3 Sauter
Sortir de la pile est très simple, il suffit de laisser ps->top--, l'élément suivant poussé dans la pile écrasera l'élément précédent.
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}3.4 Obtenir l'élément supérieur de la pile
Avant d'obtenir l'élément supérieur de la pile, il doit être jugé comme vide. S'il est vide, il n'y a pas de pointeur de sommet de pile. L'élément supérieur de la pile est l'élément dont l'indice est top-1, donc retourner ps->[ps->top-1] est l'élément supérieur de la pile.
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top-1];
}3.5 Obtenir le nombre d'éléments effectifs dans la pile
Puisque l'indice top est la position suivante de l'élément supérieur de la pile, le retour top est le nombre d'éléments valides dans la pile.
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}3.6.1 interface de type booléen
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}3.6.2 interface de type int
Ici nous convenons de retourner non nul s'il est vide, et de retourner 0 s'il n'est pas vide.
int StackEmpty(Stack* ps)
{
assert(ps);
if (0 == ps->top)
return 1;
else
return 0;
}3.7 Destruction de la pile
Libérez le tableau et rendez-le vide, et affectez la capacité et le haut de la pile à 0.
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}4. Code complet
Le code complet est dans l'entrepôt de code, entrée : Langage C : Code d'apprentissage du langage C, revoir plus - Gitee.com
5. Essai de fonctionnement
