[Structure de données] Initialisation de la liste liée d'insertion de queue, ajout et suppression de données à des positions spécifiées

1. Utilisez la méthode d'insertion de queue pour initialiser la liste chaînée

        L'un des avantages de l'utilisation de la méthode d'insertion de queue pour initialiser la liste chaînée est que les nouvelles données sont accessibles à partir de la fin de la liste chaînée , de sorte que la liste chaînée est sortie selon le principe du premier entré, premier sorti lors de la traversée de la liste chaînée. liste . Dans cet exemple, nous utilisons une structure pour le stockage des données :

	typedef struct Node //链表结构体
	{
		int Param;
		struct Node *next;
	}Node;

        En utilisant la méthode d'insertion de queue, nous devons initialiser trois frères, à savoir L, r et p (bien sûr, ce nom n'est pas nécessaire, vous pouvez en choisir trois à volonté), le premier est le nœud de tête L, qui ne stocke pas de données , uniquement en tant que rôle principal , comme le montre la figure ci-dessous :

         Parmi eux, la fonction du pointeur "L" est de pointer en permanence sur le nœud principal , de sorte que vous puissiez revenir si vous vous perdez lors de la traversée, de l'ajout et d'autres opérations ultérieures. En même temps, nous avons aussi besoin d'un pointeur "r" pour pointer vers le nœud courant :

        Comment comprendre "pointer vers le nœud actuel" ? Par exemple, lors de la traversée de toute la liste chaînée, si le quatrième nœud est traversé, le pointeur "r" pointera vers le quatrième nœud, ce que cela signifie. Enfin, il y a le pointeur "p", qui se charge uniquement de créer de nouveaux nœuds :

 

        Les fonctions des trois pointeurs ont été introduites, et l'étape suivante est l'étape d'initialisation. Le travail à faire est d'initialiser un nœud vide comme nœud principal, et de laisser r pointer sur le premier nœud :

	Node* L; 
	Node* p; 
	Node* r;

	L = (Node*)malloc(sizeof(Node));
	L->next = NULL;
	if (L == NULL)
		//报错信息
	r = L;

 2. Nœud d'insertion nouveau/fin

        La première étape de l'ajout d'un nœud consiste à générer un nœud p à partir de rien :

        Dans la deuxième étape, insérez les paramètres dont vous avez besoin dans le nœud et affectez le pointeur Next à NULL (car il n'y a pas de nœud suivant) :

        La troisième étape consiste à connecter le nœud précédent (le nœud vide pointé par L dans cet exemple) avec le nœud nouvellement initialisé :

        Enfin, pointez le pointeur "r" sur le nœud actuel (c'est-à-dire p):

        De cette façon, l'étape d'ajout d'un nœud est terminée et l'ajout d'un nouveau nœud à l'avenir consiste simplement à répéter les étapes ci-dessus. Le code est le suivant :

void NodeCreat(int Param)
{
    p = (Node*)malloc(sizeof(Node));
	p->Param = Param;
	p->next = NULL;
	r->next = p; //不可以写成L->next = p,如果不知道为什么，就尝试着插入2个以上的数据看看会发生什么
	r = p;
}

3. Supprimer le nœud à la position spécifiée

        Il y aura de nombreuses situations dans la suppression du nœud à l'emplacement spécifié. Nous devons prendre différentes mesures de pré-erreur en fonction de différentes situations. Expliquons d'abord la méthode de suppression du nœud et initialisons un pointeur q pour trouver l'emplacement précédent de la cible . Noeud :

        Suppression ultérieure :

         Lors de la suppression d'un nœud, les situations suivantes se produiront :

• Le premier nœud est supprimé
• La suppression est le premier nœud && le premier nœud n'est que le dernier nœud
• Le nœud du milieu est supprimé
• Supprimer le nœud du milieu && souhaitez supprimer le dernier nœud

        Pour la situation ci-dessus, il existe le code suivant :

void DeleteNode(int location)
{
	Node* q = L->next;
	Node* Delq;
	int Tmp_location = 0;

	while (L->next != NULL) //不止有一个节点
	{
		if (Tmp_location == location) //删除第一个节点
		{
			if (L->next->next == NULL) //第一个节点是最后一个节点
			{
				free(L->next);
				L->next = NULL;
				r = L;
				break;
			}

			Delq = q;
			L->next = q->next;
			free(Delq);
			break;
		}
		else if (Tmp_location == location - 1) //删除中间的节点
		{
			if (q->next->next == NULL) //删除最后一个节点
			{
				free(q->next);
				q->next = NULL;
				r = q;
				break;
			}

			Delq = q->next;
			q->next = q->next->next;
			r = q->next;
			free(Delq);
			break;
		}
		else
		{
			q = q->next;
			Tmp_location++;
		}
	}
}

         Le code de suppression de nœud ci-dessus réagit différemment à différentes situations pour éviter les plantages lors de la suppression de nœuds, et en même temps garder le pointeur r à la position actuelle après la suppression pour faciliter les opérations ultérieures