Implémentation d'une pile avec une liste chaînée en langage C

J'apprends actuellement la structure des données, donc cela équivaut à prendre des notes. J'espère que cela sera utile à tout le monde.

Tout le monde connaît la pile, donc je ne la répéterai pas ici.

Dans la définition de la pile et de la liste liée dans le fichier d'en-tête, la liste liée entière est LinkStack et l'élément supérieur qui y est stocké est le nœud. L'avantage de les stocker séparément est qu'il est pratique pour la compréhension et la modification ultérieure

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct LNode{
	int data;  // 栈的数据 
	LNode* next; // 指向下一个节点 
};

struct LinkStack{
	LNode* top;
	int len;  // 存储栈的长度 
	int maxlen;  // 栈的最大长度 
}; 

Créer une pile Il convient de noter que len doit être affecté à -1 à l'avance pour s'assurer que notre valeur maxlen est précise et éviter que la valeur maximale soit de 5, mais en fait, seuls 4 nœuds peuvent être stockés.

// 创建一个栈 
LinkStack* Create(int maxlen){
	LinkStack* ls = (LinkStack*)malloc(sizeof(LinkStack));
	ls->top = NULL;
	ls->len = -1;
	ls->maxlen = maxlen;
	return ls;
}

Rendez la pile vide, modifiez simplement len ​​directement, ici (paresseux) n'est pas gratuit.

// 将栈置空 
void FreeAll(LinkStack* ls){
	ls->len = -1;
} 

Si la pile brisée est vide

// 判断栈是否为空 
bool IsEmpty(LinkStack* ls){
	return ls->len <= 0;
} 

Vérifiez si la pile est pleine

// 判断栈是否已满
bool IsFull(LinkStack* ls){
	return ls->len == ls->maxlen;
} 

Pour pousser les données dans la pile, vous devez faire attention à la méthode d'insertion de la tête , la pile n'a qu'une seule entrée

// 将x压入栈
bool push(LinkStack* ls, int x){
	if(IsFull(ls)){
		printf("栈已满！");
		return false;
	}
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	newNode->data = x;
	newNode->next = ls->top;
	ls->top = newNode;
	ls->len++;
	return true;
}

L'élément supérieur de la pile est extrait de la pile et la méthode de suppression intermédiaire ne peut pas être fournie, car la pile n'a qu'une seule sortie

// 将栈顶元素出栈
bool pop(LinkStack* ls){
	if(IsEmpty(ls)){
		printf("栈为空！"); 
		return false;
	}
	LNode* tool = ls->top;
	ls->top = tool->next;
	ls->len--;
	return true;
} 

Obtenir l'élément supérieur de la pile, cette méthode peut être écrite avec le popping, c'est-à-dire obtenir la valeur de cet élément au passage lors du popping de la pile

// 获取栈顶元素
int getTop(LinkStack* ls){
	return ls->top->data;
}

L'impression de tous les éléments de la pile est limitée à la raison de la liste chaînée unique, ici elle ne peut être imprimée qu'en sens inverse, c'est-à-dire en imprimant du haut de la pile vers le bas de la pile. Vous pouvez également remplacer la liste chaînée par une double liste chaînée

// 打印栈的所有元素
void printAll(LinkStack* ls){
	LNode* tool = ls->top;
	while(tool){
		printf("%d  ", tool->data);
		tool = tool->next;
	}
}

La fonction principale finale, testez-la simplement.

int main(){
	int i = 0, n = 0;
	LinkStack* ls = Create(5);
	while(i < 7){
		scanf("%d", &n);
		if(!push(ls,n)){
			break;
		}
		i++;
	}
	printf("\n");
	pop(ls);
	printAll(ls);
	return 0;
}

Si vous avez des questions, vous pouvez directement m'envoyer un message ~~~~~

J'espère partager avec vous