Pile (table linéaire à fonctionnement limité) --- Version langage C

contenu

Tout d'abord, le concept de pile

Définition de pile

Une pile est une liste linéaire restreinte aux opérations d'insertion ou de suppression uniquement à la fin de la liste. Par conséquent, pour la pile, la queue de la table a une signification particulière, appelée le haut de la pile, et en conséquence, le segment d'en-tête est appelé le bas de la pile. Une liste vide sans éléments est appelée une pile vide.

Haut de la pile : La fin de la liste linéaire qui permet les insertions et les suppressions.
Bas de la pile : Une extrémité fixe qui ne permet pas l'insertion et la suppression.
Pile vide : une liste vide sans éléments.
Caractéristiques opérationnelles de la pile : Last In First Out (Last In First Out)

Supposons qu'une certaine pile S=(a ₁ , a ₂ ,..., a _n ), alors a ₁ est appelé l'élément inférieur de la pile, et a _n est l'élément supérieur de la pile.
Les éléments de la pile sont poussés dans la pile dans l'ordre a ₁ , a ₂ ,..., an _n , et le premier élément à sortir de la pile doit être l'élément supérieur de la pile.
En d'autres termes, la modification de la pile s'effectue selon le principe du dernier entré premier sorti, que l'on peut appeler LIFO ;

Schéma de principe de la pile :
insérez la description de l'image ici

Propriétés mathématiques des piles

n éléments différents sont poussés dans la pile, et le nombre de permutations différentes des éléments sautés est $\frac{1}{n+1}C_{2n}^n$ . Cette formule s'appelle le nombre de Cattelan.

Deuxièmement, le fonctionnement de base de la pile

InitStack(*S): construit une pile vide S
StackEmpty(S): Retourne TRUE si la pile S est vide, sinon FALSE.
Push(*S,e): Insère l'élément e comme nouvel élément supérieur de la pile
Pop(*S,*e): Supprime l'élément supérieur de S de la pile et retourne sa valeur avec e.
StackLength(S): Renvoie le nombre d'éléments dans la pile S, c'est-à-dire la longueur de la pile.
GetTop(S,*e): utilisez e pour retourner l'élément du haut de la pile
StackTraverse(S): Parcourez la pile S du bas de la pile au haut de la pile et imprimez les éléments qu'elle contient
DestoryStack(*S): détruire la pile
ClearStack(*S): la pile S est effacée pour vider la pile

Ensuite, il est divisé en stockage séquentiel et stockage en chaîne de la pile pour mettre en œuvre ces opérations.

3. Pile séquentielle

Une pile qui utilise le stockage séquentiel est appelée une pile séquentielle, qui utilise un groupe d'unités de stockage avec des adresses consécutives pour stocker des éléments de données du bas de la pile au sommet de la pile.

3.1 Définition de pile séquentielle

La pile de séquences est en fait une table de séquences avec des opérations limitées, et nous utilisons ici l'allocation dynamique. Pour le contenu de la table de séquence, vous pouvez visualiser la table de séquence (stockage séquentiel des tables linéaires) - Version langage C
Toujours sur cet exemple, comment mémorise-t-on la table ?

identifiant	Nom	la description
1	Shi Qiang	Le soutien le plus fort
2	Chapitre Mer du Nord	Je n'ai pas besoin d'un pochoir, je suis le maître de mon esprit
3	Luo Ji	Les humains ne remercient pas Luo Ji
4	Vador	Perdre de l'humanité, perdre beaucoup. perdre la bête, tout perdre

Étape 1 : Déclarez le type d'élément de données

Nous utilisons d'abord la structure pour déclarer le type de l'élément de données (correspondant à une ligne de données dans le tableau)

typedef struct{
    
    
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}SElemType;//此处的SElemType是个类型名

Étape 2 : Définition de la pile de séquences

#define InitSize 10;//栈的初始长度
#define ListIncrement 2;//扩容时的分配增量
typedef struct{
    
    
    SElemType *base;//栈的基地址，指示动态分配的数组的指针
    SElemType *top;//栈顶指针
    int MaxSize;//当前栈的最大存储长度
}SqStack;//顺序栈的类型定义

3.2 Fonctionnement de la pile séquentielle

La structure de la pile n'existe pas :base==NULL;
La pile est vide :base==top
Sur la pile : *top=e; top++;attribuez d'abord, puis ajoutez-en un
Faites éclater la pile : top--; *e=*top;décrémentez d'abord, puis revenez

`InitStack(*S)`: construit une pile vide S

/*初始化*/
int InitStack(SqStack *S){
    
     
   S->base=(SElemType *)malloc(sizeof(SElemType)*InitSize); //给栈分配存储空间
   if(!S->base) return FALSE; //分配失败返回FALSE
   S->top=S->base;//空栈的top和base指向同一个位置
   S->MaxSize=InitSize;//初始最大长度
   return TRUE;//成功初始化返回TRUE
}

`StackEmpty(S)`: Retourne TRUE si la pile S est vide, sinon FALSE.

/*判断是否为空栈*/
int StackEmpty(SqStack S){
    
    
    if (S.base==S.base) return TRUE;
    return FALSE;
}

`Push(*S,e)`: Insère l'élément e comme nouvel élément supérieur de la pile

/*插入*/
int Push(SqStack *S,SElemType e){
    
    
    if(S->top-S->base>=S->MaxSize){
    
    
        S->base=(SElemType*)realloc(S->base,(S->MaxSize+StackIncrement)*sizeof(SElemType));//栈满追加存储空间
        if (!S->base) return FALSE;//存储分配失败
        S->top=S->base;
        S->MaxSize+=StackIncrement;
    }
    *S->top++=e;//先赋值再加一
    return TRUE;
}

`Pop(S,e)`: Supprime l'élément supérieur de S de la pile et retourne sa valeur avec e.

/*删除*/
int Pop(SqStack *S,SElemType *e){
    
       
    if (S->top==S->base) return FALSE;//如果栈为空，返回
    *e=*(--S->top);//先减一再返回  
    return TRUE;
}

`StackLength(S)`: Renvoie le nombre d'éléments dans la pile S, c'est-à-dire la longueur de la pile.

/*求栈长*/
int StackLength(SqStack S){
    
    
    int length=0;
    for( ;S.base<S.top;S.base++){
    
    
        length++;
    }
    return length;
}

`GetTop(S,*e)`: utilisez e pour retourner l'élément du haut de la pile

/*获取栈顶元素*/
int GetTop(SqStack S,SElemType *e){
    
    
    if (S.top==S.base) return FALSE;
    *e=*(S.top-1);
    return TRUE;  
}

`StackTraverse(S)`: Parcourez la pile S du bas de la pile au haut de la pile et imprimez les éléments qu'elle contient

/*打印*/
void StackTraverse(SqStack S){
    
    
    for ( ;S.base<S.top;S.base++){
    
    
        printf("id=%d,name=%s,description=%s\n",S.base->id,S.base->name,S.base->description);
    }   
}

`DestoryStack(*S)`: détruire la pile

/*销毁顺序表*/
void DestroyStack(SqStack *S){
    
    
    free(S->base);
    S->MaxSize=0;
    S->base=NULL;
    S->top=NULL;
}

`ClearStack(*S)`: la pile S est effacée pour vider la pile

/*清空栈*/
void ClearStack(SqStack *S){
    
    
    S->top=S->base;
}

3.3 Code source complet

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define InitSize 10  //表的初始长度
#define StackIncrement 2  //扩容时的分配增量
typedef struct{
    
    
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}SElemType;//此处的SElemType是个类型名

typedef struct{
    
    
    SElemType *base;//栈的基地址，指示动态分配的数组的指针
    SElemType *top;//栈顶指针
    int MaxSize;//当前栈的最大存储长度
}SqStack;//顺序栈的类型定义

/*初始化*/
int InitStack(SqStack *S){
    
     
   S->base=(SElemType *)malloc(sizeof(SElemType)*InitSize); //给栈分配存储空间
   if(!S->base) return FALSE; //分配失败返回FALSE
   S->top=S->base;//空栈的top和base指向同一个位置
   S->MaxSize=InitSize;//初始最大长度
   return TRUE;//成功初始化返回TRUE
}
int StackEmpty(SqStack S){
    
    
    if (S.base==S.base) return TRUE;
    return FALSE;
}

/*插入*/
int Push(SqStack *S,SElemType e){
    
    
    if(S->top-S->base>=S->MaxSize){
    
    
        S->base=(SElemType*)realloc(S->base,(S->MaxSize+StackIncrement)*sizeof(SElemType));//栈满追加存储空间
        if (!S->base) return FALSE;//存储分配失败
        S->top=S->base;
        S->MaxSize+=StackIncrement;
    }
    *S->top++=e;//先赋值再加一
    return TRUE;
} 

/*删除*/
int Pop(SqStack *S,SElemType *e){
    
       
    if (S->top==S->base) return FALSE;//如果栈为空，返回
    *e=*(--S->top);
    return TRUE;
}

/*求栈长*/
int StackLength(SqStack S){
    
    
    int length=0;
    for(;S.base<S.top;S.base++){
    
    
        length++;
    }
    return length;
}

/*获取栈顶元素*/
int GetTop(SqStack S,SElemType *e){
    
    
    if (S.top==S.base) return FALSE;
    *e=*(S.top-1);
    return TRUE;  
}

/*打印*/
void StackTraverse(SqStack S){
    
    
    for ( ;S.base<S.top;S.base++){
    
    
        printf("id=%d,name=%s,description=%s\n",S.base->id,S.base->name,S.base->description);
    }   
}

/*销毁顺序表*/
void DestroyStack(SqStack *S){
    
    
    free(S->base);
    S->MaxSize=0;
    S->base=NULL;
    S->top=NULL;
}

/*清空栈*/
void ClearStack(SqStack *S){
    
    
    S->top=S->base;
}

int main(void){
    
    
///初始化
    
    SqStack S;
    int i=InitStack(&S);
    if (i==1){
    
    
        printf("初始化成功\n");
    }else{
    
    
        printf("初始化失败\n"); 
    }
    printf("\n");    
///插入
    SElemType a[4]={
    
    
        {
    
    1,"史强","最强辅助"},
        {
    
    2,"章北海","我不需要钢印，我是自己思想的主人"},
        {
    
    3,"罗辑","人类不感谢罗辑"},
        {
    
    4,"维德","失去人性，失去很多。失去兽性，失去一切"}
    };
    int j;
    for ( j = 0; j < 4; j++){
    
    
        i=Push(&S,a[j]);
    }
    StackTraverse(S);
    printf("\n"); 
删除
    SElemType e;
    Pop(&S,&e);    
    printf("被删除的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("删除之后：\n");
    StackTraverse(S);
    printf("\n"); 
//获取栈顶元素
    i=GetTop(S,&e);
    printf("栈顶元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");      
//销毁查找       
    DestroyStack(&S);
    StackTraverse(S);//打印为空了
}

résultat de l'opération :

初始化成功

id=1,name=史强,description=最强辅助
id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
id=3,name=罗辑,description=人类不感谢罗辑
id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

被删除的元素：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
删除之后：
id=1,name=史强,description=最强辅助
id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
id=3,name=罗辑,description=人类不感谢罗辑

栈顶元素：id=3,name=罗辑,description=人类不感谢罗辑