Pile séquentielle
1. Concept
La pile est une sorte 仅在表尾进行插入或者删除操作的线性表. Et le début et la fin de la table ont des significations particulières: la tête de la table est généralement appelée 栈底, la fin de la table (la position du dernier élément) est appelée 栈顶, et 栈底=栈顶la pile sans éléments ou s'appelle la pile 空栈.
Par conséquent, la pile est une 先进后出structure de table. Cette situation est très similaire à notre gare de répartition des trains.
2. Définition de la structure de la pile
Étant donné que la structure de stockage interne de la pile peut utiliser une structure séquentielle ou une structure en chaîne, mais que la méthode de stockage dans cette partie est similaire à la liste linéaire précédente et à la liste liée individuellement, cet article adopte donc la méthode de stockage séquentiel à réaliser.
1. Définition de la pile
Pour une pile, nous devons définir trois parties, l'une est de basestocker nos données comme notre «conteneur» de base, puis nous devons avoir un toppointeur du haut de la pile pour pointer vers notre élément du haut de la pile actuel, car il s'agit d'une table de séquence, il faut donc aussi avoir une longueur maximale maxlenà stocker base, afin de ne pas franchir la frontière. topCela peut être une base+topméthode de remodelage pour amener le pointeur vers le haut de la pile. Bien sûr, vous pouvez aussi le topdéclarer directement comme la basemême classe que celle et stocker le pointeur en haut de la pile. Parce qu'il s'agit à l'origine d'une table de séquence, le plus simple sera le mieux, il est donc stocké de manière plastique.
2. Initialisez la pile
Pour l'initialisation de la pile, il suffit de demander un espace avec une longueur par défaut, de lui attribuer base, puis de le maxlenmettre à jour à la longueur que nous avons initialisée, et enfin top=0, il est pointé base.
3. Détruisez la pile
freeLaissez-nous directementbase
4. La pile est-elle vide
Nous jugeons directementtop==0
5. Longueur de pile
Comme il s'agit d'une structure de stockage séquentiel, il n'est pas nécessaire de parcourir toute la table et de revenir directement top. Le pointeur du haut de la pile correspond à la longueur de notre pile.
6. L'élément supérieur de la pile
Si la pile n'est pas vide, la *(base+top)valeur renvoyée fera l'affaire
7. Poussez dans la pile
Nous avons seulement besoin de mettre à jour la position du pointeur en haut de la pile et d'affecter la valeur que nous voulons pousser, de sorte que l'élément soit poussé sur la pile.
Bien sûr, nous devons juger si basel'espace de stockage est suffisant, et si ce n'est pas suffisant, nous en avons toujours besoin realloc base, afin de ne pas provoquer de hors limites. Selon mon habitude, j'aime vérifier et m'étendre après avoir été mis dans la pile, et être prêt pour le maître.
8. Pop
Renvoyez la valeur de l'adresse pointée par le pointeur de pile actuel, puis ajoutez 栈顶指针-1.
Troisièmement. Mise en œuvre du code
Tant que vous connaissez le principe, la mise en œuvre est relativement simple, il n'est donc pas nécessaire d'ajouter des commentaires.
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define DEFAULT_LEN 20
#define EXTEND_LEN 5
typedef struct elemType{
int data;
}elemType;
typedef struct Stack{
elemType *base;
int top;
int maxlen;
}Stack;
Stack* StackInit(void);
int GetTop(Stack *S, elemType *elem);
int Push(Stack* S, elemType elem);
elemType Pop(Stack* S);
int IsEmpty(Stack *S);
int main()
{
Stack* s = StackInit();
elemType test;
test.data = 123;
Push(s,test);
test.data = 456;
Push(s,test);
test.data = 789;
Push(s,test);
while(IsEmpty(s) == 0)
{
printf("%d\n", Pop(s).data);
}
return 0;
}
Stack* StackInit(void)
{
Stack *S = (Stack*)malloc(sizeof(Stack));
if (S == NULL)
{
return ERROR;
}
S->base = (elemType *)malloc(sizeof(elemType)*DEFAULT_LEN);
S->top = 0;
S->maxlen = DEFAULT_LEN;
if (S->base != NULL)
{
return S;
}
else
{
exit(1);
}
}
int GetTop(Stack *S, elemType *elem)
{
if (S->base != NULL && S->top != 0)
{
elem = S->base + S->top;
return OK;
}
else
{
return ERROR;
}
}
int Push(Stack *S, elemType elem)
{
if (S->top < S->maxlen)
{
S->top += 1;
*(S->base+S->top) = elem;
if (S->top >= S->maxlen)
{
S->base = (elemType*)realloc(S->base, sizeof(elemType)*(S->maxlen + EXTEND_LEN));
if (S->base != NULL)
{
return OK;
}
else
{
exit(1);
}
}
}
else
{
return ERROR;
}
}
elemType Pop(Stack* S)
{
elemType *elem;
if (S->top > 0)
{
elem = S->base+S->top;
S->top -= 1;
return *elem;
}
else
{
exit(2);
}
}
int IsEmpty(Stack *S)
{
if (S->top > 0)
{
return 0;
}
else
{
return 1;
}
}