Structure de données: pile séquentielle et pile de chaîne

Empiler

La pile est une table linéaire avec Last In Fast Out. Elle est limitée à l'insertion et à la suppression de tables linéaires à la fin de la table. L'extrémité qui permet l'insertion et la suppression est appelée le haut de la pile.

Diagramme de pile

Variation d'empilement et hors pile

Les éléments de la pile la plus avancée ne sont pas nécessairement affichés en dernier, car la pile restreint les positions d'insertion et de suppression de la table linéaire, et ne limite pas le temps pour les éléments d'entrer et de sortir, c'est-à-dire lorsque tous les éléments ne sont pas poussés dans la pile , L'élément qui commence en premier peut également être sauté, du moment qu'il s'agit de l'élément supérieur de la pile.

Par exemple, les éléments de nombres entiers 1, 2 et 3 sont poussés tour à tour dans la pile, et l'ordre d'empilement peut être:

• Le premier type, 1, 2, 3 in, puis 3, 2, 1, out, l'ordre de pile 321
• Le deuxième type, 1 entrée, 1 sortie, 2 entrées, 2 sorties, 3 entrées, 3 sorties, dans l'ordre de la pile 123
• Le troisième type, 1 entrée, 2 entrées, 2 sorties, 1 sortie, 3 entrées, 3 sorties, dans l'ordre de la pile 213
• Le quatrième type, 1 entrée, 1 sortie, 2 entrées, 3 entrées, 3 sorties, 2 sorties, dans l'ordre de la pile 132
• Le cinquième type, 1 entrée, 2 entrée, 2 sortie, 3 entrée, 3 sortie, 1 sortie, séquence d'empilage 231

Il y a 5 commandes d'empilage pour 3 éléments

Structure de stockage séquentiel de la pile

La pile est un cas particulier de la table linéaire. La structure de stockage séquentiel de la pile est en fait une simplification du stockage séquentiel de la table linéaire, appelée pile séquentielle. La structure de la pile séquentielle est la suivante:

typedef int ElemType;   /* ElemType类型根据实际情况而定，这里假设为int */  
typedef struct Stack
{
    
    
	Elemtype *elem;
	int top;   /* 用于栈顶指针 */
	int stacksize;  /* 栈的空间大小 */
}SqStack;

Initialisation de la pile séquentielle

1. Ouvrir l'espace initial
2. Initialiser le haut
3. Initialiser la taille de la pile

void InitStack(PStack st)
{
    
    
	assert(st != NULL);  //确保st不为空指针
			
	st->elem = (ElemType*)malloc(sizeof(ElemType)*STACK_INIT_SIZE);
	st->stacksize = STACK_INIT_SIZE;
	st->top = -1;
}

Expansion séquentielle de la pile

1. Ouvrez l'espace
2. Mettre à jour la taille de la pile

static void AppendStack(PStack st)//扩容
{
    
    
	assert(st != NULL);
	
	st->elem = (ElemType*)realloc(st->elem, st->stacksize + sizeof(ElemType)*STACKINCREMENT);
	st->stacksize += STACKINCREMENT;
}

Push de la pile séquentielle (Push)

Pour l'opération de poussée, trois choses sont réellement effectuées

1. Jugez que la pile est pleine
2. Pointeur supérieur de la pile plus un
3. Attribuez l'élément nouvellement inséré à l'espace supérieur de la pile

void Push(PStack st, ElemType val)
{
    
    
	assert(st != NULL);
		
	if (st->top == st->stacksize)  //判断栈满
	{
    
    
		AppendStack(st);
	}
	st->top++;  //栈顶指针加一
	st->elem[st->top] = val;  //将新插入元素赋值给栈顶空间
	
}

Pop de pile séquentielle (Pop)

Si la pile n'est pas vide, placez l'élément supérieur de la pile sur e et diminuez le pointeur du haut de un

int Pop(PStack st, ElemType *e)  // 若栈不为空，则弹出栈顶元素给e，栈顶指针减一
{
    
    
	assert(st != NULL);
		
	if (st->top >= 0)
	{
    
    
		*e = st->elem[st->top];
		st->top--;
		return 1;
	}
	return 0;	
}

Destruction de la pile séquentielle

void Destory(PStack st)
{
    
    
	assert(st != NULL);

	free(st->elem);
	st->elem = NULL;
	st->stacksize = 0;
}

Vidage séquentiel de la pile

void Clear(PStack st)
{
    
    
	assert(st != NULL);
	
	st->top = 0;
}

La pile de séquences est vide

bool IsEmpty(PStack st)
{
    
    
	assert(st != NULL);

	return st->top == -1;
}

Obtenez l'élément supérieur de la pile séquentielle

ElemType GetTop(PStack st)
{
    
    
	assert(st != NULL);
	return st->elem[st->top];
}

Structure de stockage chaînée de la pile

La structure de stockage en chaîne de la pile consiste à implémenter la pile dans un mode de liste liée, appelée pile de chaînes. La
pile de chaînes place le haut de la pile en tête de la liste liée unique, comme illustré dans la figure suivante: La

structure de la pile de chaînes est la suivante:

typedef struct StackNode  // 栈结点
{
    
    
	ElemType data;
	struct StackNode *next;
}StackNode,*LinkStackPtr;

typedef struct LinkStack  // 链栈
{
    
    
	LinkStackPtr top;
	int count;
}LinkStack;

La plupart des opérations de la pile de chaînes sont similaires à celles d'une seule liste liée, à l'exception des insertions et des suppressions.

Poussée de la pile de chaînes (Poussée)

En supposant que le nouveau nœud s dont la valeur d'élément est e doit être poussé dans la pile, et top est le pointeur du haut de la pile, le diagramme schématique de l'insertion dans la pile est le suivant:

1. Assignez l'élément du haut de la pile actuel au successeur immédiat du nouveau nœud
2. Mettez à jour le pointeur du haut de la pile pour qu'il pointe vers le nouvel élément

Status Push(LinkStack *LS, ElemType e)
{
    
    
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StacNode));
	s->data = e;
	
	s->next = LS->top; //将当前的栈顶元素赋值给新节点的直接后继
	LS->top = s;  //更新栈顶指针，使其指向新元素
	
	LS->count++;
	
	return OK;
}

Pop de la pile de chaînes (Pop)

Supposons que la variable p soit utilisée pour stocker le nœud supérieur de la pile à supprimer

1. Attribuez le nœud supérieur de la pile à p, comme indiqué à l'étape 1
2. Le pointeur du haut de la pile descend d'un bit, comme illustré à l'étape 2 ci-dessous
3. Release node p

//若栈不为空，则删除栈顶元素，用e返回其值，并返回OK；否则返回ERROR
Status Pop(LinkStack *S, ElemType *e)
{
    
    
	LinkStackPtr p;
	if(StackEmpty(*S))
	{
    
    
		return ERROR;
	}
	*e = S->top->next;
	
	p = S->top; //将栈顶结点赋值给p，如上图步骤1
	S->top = S->top->next;  //栈顶指针下移一位，如上图步骤2
	free(p);  //释放结点p
	S->count--;
	
	return OK;
}

Comparaison de la pile séquentielle et de la pile de chaînes

La complexité temporelle de l'empilement et de l'empilement de la pile séquentielle et de la pile en chaîne est O (1). Pour les performances spatiales, la pile séquentielle doit déterminer une longueur fixe à l'avance, ce qui peut entraîner un gaspillage d'espace mémoire, mais son avantage est qu'il est pratique d'accéder et de localiser, tandis que la pile de chaîne nécessite que chaque élément ait un champ de pointeur, qui également Une surcharge de mémoire est ajoutée, mais la longueur de la pile peut être développée de manière flexible. Donc, la différence entre eux est comme la différence entre une liste séquentielle et une liste chaînée.
Si les modifications des éléments lors de l'utilisation de la pile sont imprévisibles, parfois petites et parfois importantes, il est préférable d'utiliser une pile de chaînes; sinon, si ses modifications sont dans une plage contrôlable, vous pouvez utiliser une pile séquentielle