Table des matières
1. Supprimez tous les nœuds de la liste chaînée qui sont égaux à la valeur donnée val.
2. Inverser une liste chaînée.
4. Entrez une liste chaînée et sortez le kième dernier nœud de la liste chaînée
On ne vit qu'une fois.
1. Supprimez tous les nœuds de la liste liée qui sont égaux à la valeur donnée val .
https://leetcode.cn/problems/remove-linked-list-elements/description/
Affichage des codes :
struct ListNode* removeElements(struct ListNode* head, int val){
struct ListNode* cur = head;
struct ListNode* prev = NULL;
while (cur)
{
struct ListNode* next = cur->next;
if (cur->val != val)
{
prev = cur;
cur = next;
}
else
{
if (prev == NULL)
{
head = next;
free(cur);
cur = next;
}
else
{
prev->next = next;
free(cur);
cur = next;
}
}
}
return head;
}Idées : (1) Jugez d'abord si cur est vide ou non, puis jugez s'il y a val, si oui, jugez si c'est dans la tête, si oui, c'est un cas, sinon, c'est un autre cas. (2) Dans le premier cas, la situation donnée par le sens de la question ; dans le second cas, il y a des valeurs consécutives au milieu (les deux premières peuvent être combinées) ; dans le troisième cas, il y en a 6 ou 6s consécutifs au début ; le quatrième cas : vide
Note : (1) Pour chaque question, plusieurs situations doivent être considérées, pas seulement la situation donnée par Likou.
(2) Erreur de compilation : erreur de code ; erreur d'exécution : erreur de logique
2. Inverser une liste chaînée.
https://leetcode.cn/problems/reverse-linked-list/
Affichage du code 1 : (idée 1)
struct ListNode* reverseList(struct ListNode* head){
struct ListNode* cur = head;
struct ListNode* prev = NULL;
while(cur)
{
struct ListNode* next = cur->next;
cur ->next = prev;
prev = cur;
cur = next;
}
return prev;
}Affichage du code 2 : (Réflexion 2)
struct ListNode* reverseList(struct ListNode* head)
{
struct ListNode* cur = head;
struct ListNode* newhead = NULL;
while (cur)
{
struct ListNode* next = cur->next;
cur->next = newhead;
newhead = cur;
cur = next;
}
return newhead;
}Idée 1 : pointer sur la précédente
Idée 2 : Insérez le head, créez une nouvelle liste chaînée, newlist, qui est vide. Enregistrez d'abord la suivante de l'ancienne liste chaînée cur, puis, cur->next pointe vers la nouvelle liste chaînée, et l'en-tête de la nouvelle liste chaînée pointe vers cur, en répétant ceci jusqu'à ce que cur soit vide.
Remarque : Si vous pouvez écrire une boucle, n'écrivez pas de récursivité
3. Étant donné une liste chaînée simple non vide avec un nœud principal head, renvoie le nœud du milieu de la liste chaînée. S'il y a deux nœuds intermédiaires, renvoyez le deuxième nœud intermédiaire.
https://leetcode.cn/problems/middle-of-the-linked-list/description/
Affichage des codes :
struct ListNode* middleNode(struct ListNode* head)
{
struct ListNode* slow = head;
struct ListNode* fast = head;
while (fast && (fast ->next))
{
slow = slow ->next;
fast = fast->next->next;
}
return slow;
}Idée : définissez d'abord deux pointeurs, l'un (lent) parcourt un à la fois, et l'autre (rapide) parcourt deux données à la fois, lorsqu'il y a des nombres impairs : lorsque fast->next est égal à NULL, lent est juste dans le milieu. Lorsqu'il y a des nombres pairs, lorsque fast est égal à NULL, slow n'est que la deuxième des valeurs médianes.
Remarque : while (fast && (fast ->next)); Lorsque les deux conditions sont liées, faites attention au recto et au verso. Cette condition de code s'inversera et une erreur se produira.
4. Entrez une liste chaînée et sortez le kième dernier nœud de la liste chaînée
Affichage des codes :
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
// write code here
struct ListNode* slow = pListHead;
struct ListNode* fast = pListHead;
for (int i = 0; i < k; i++)
{
//k大于链表的长度
if (fast == NULL)
{
return NULL;
}
fast = fast->next;
}
while (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
return slow;
}Idée : définissez d'abord deux pointeurs, rapide et lent ; d'abord laissez aller K rapide, puis lent et gras vont ensemble, quand rapide est NULL, lent est le kième à partir du bas.
Remarque : K est supérieur à la liste chaînée