[Structure de données] Implémentation d'une pile séquentielle en langage C

Bonjour à tous, je n'ai pas blogué depuis longtemps. J'ai été occupé ces derniers temps. Je me concentre principalement sur java, et l'autre partie est sur la structure des données. En même temps, je dois m'occuper de certains cours scolaires, tels que des nombres élevés et des choses discrètes. , résultant en ne pas bloguer pendant une longue période. J'écrirai des blogs sur Java et les structures de données et les algorithmes à l'avenir.

Eh bien, sans plus tarder, je parle aujourd'hui de quelques opérations de base sur la pile séquentielle de structures de données en langage c.

Définition de la pile séquentielle

Tout d'abord, examinons brièvement la pile séquentielle. Nous savons que la table linéaire est divisée en liste séquentielle et en liste chaînée simple selon le stockage séquentiel ou le stockage en chaîne. De même, selon les différentes méthodes de stockage, nous divisons la pile dans des piles de stockage séquentielles. C'est ce qu'on appelle une pile séquentielle, et une chaîne stockée dans une chaîne est appelée une pile de chaînes. Ce dont nous parlons, c'est de la pile séquentielle. En fait, avec une certaine connaissance du tableau linéaire précédent, il est relativement aisé de comprendre le fonctionnement de la pile.

Compréhension de la pile séquentielle

La question vient? Comment le définit-on ? Habituellement, nous pouvons utiliser un tableau et une variable qui enregistre la position de l'élément supérieur de la pile, et la position supérieure de la pile utilise la variable entière Top pour enregistrer la valeur en indice de l'élément supérieur actuel de la pile. Lorsque Top==-1, cela signifie une pile vide. Lorsque top==MAXSIZE-1, cela signifie que la pile est pleine. Eh bien, commençons à implémenter la pile séquentielle.

Prêt à travailler

1. Définition de la macro et son changement de nom

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; 
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

2. Structure (représentation de la pile séquentielle)

/* 顺序栈结构 */
typedef struct
{
        SElemType data[MAXSIZE];
        int top; /* 用于栈顶指针 */
}SqStack;

Mise en œuvre

1. Initialisation

/*  构造一个空栈S */
Status InitStack(SqStack *S)
{ 
        /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
        S->top=-1;
        return OK;
}

2. Vide

/* 把S置为空栈 */
Status ClearStack(SqStack *S)
{ 
        S->top=-1;
        return OK;
}

3. Déterminez s'il est vide

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqStack S)
{ 
        if (S.top==-1)
                return TRUE;
        else
                return FALSE;
}

4. Trouvez la longueur

/* 返回S的元素个数，即栈的长度 */
int StackLength(SqStack S)
{ 
        return S.top+1;
}

5. Trouvez l'élément supérieur de la pile

/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(SqStack S, SElemType* e)
{
    if (S.top == -1) {
        return ERROR;
    }
    else {
        *e = S.data[S.top];
        return OK;
    }
}

6. Poussez dans la pile (en jugeant si elle est pleine)

/* 插入元素e为新的栈顶元素 */
Status Push(SqStack* S, SElemType e)
{
    if (S->top == MAXSIZE - 1) /* 栈满 */
    {
        return ERROR;
    }
    S->top++;				/* 栈顶指针增加一 */
    S->data[S->top] = e;  /* 将新插入元素赋值给栈顶空间 */
    return OK;
}

7. Faites éclater la pile (en jugeant si elle est vide)

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqStack* S, SElemType* e)
{
    if (S->top == -1)
        return ERROR;
    *e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
    S->top--;				/* 栈顶指针减一 */
    return OK;
}

8. Traversée

/* 从栈底到栈顶依次对栈中每个元素显示 */
Status StackTraverse(SqStack S)
{
    int i;
    i = 0;
    while (i <= S.top)
    {
        visit(S.data[i++]);
    }
    printf("\n");
    return OK;
}
Status visit(SElemType c)
{
    printf("%d ", c);
    return OK;
}

fonction principale

int main()
{
    int j;
    SqStack s;
    int e;
    if (InitStack(&s) == OK)
        for (j = 1; j <= 10; j++)
            Push(&s, j);
    printf("栈中元素依次为：");
    StackTraverse(s);
    Pop(&s, &e);
    printf("弹出的栈顶元素 e=%d\n", e);
    printf("栈空否：%d(1:空 0:否)\n", StackEmpty(s));
    GetTop(s, &e);
    printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(s));
    ClearStack(&s);
    printf("清空栈后，栈空否：%d(1:空 0:否)\n", StackEmpty(s));

    return 0;
}

Eh bien, cette fois, une certaine connaissance de la pile de séquences est terminée.