leetcode链表小练（1.反转链表2.链表的中间节点3.合并两个有序链表4.环形链表①5.环形链表②）详解 (??? ? ??)?????? ?

目录

一.反转链表

思路一反转指针反向：

思路二头插法：

二.链表的中间节点：

三.合并两个有序数组:?

?思路一：从头开始，取两个链表中小的那个尾插到新链表。定义指针head,tail指向空，代表新链表的头结点。

思路二：创建一个空的头指针（哨兵位），优化代码?：

?四.环形链表①：

?五.环形链表②：

---

分享几个链表经典问题给大家，有不足的地方欢迎指出~感谢支持?づ?ど

?

一.反转链表

题目：

?

思路一反转指针反向：

设置三个指针变量n1,n2,n3；分别指向NULL，第一个节点，第二个节点。将第n2的next指向n1,n1给n2，n2给n3,然后n3指向下一个节点，当n3=NULL是就不用在移动了，总的循环终止条件是n2!=NULL.

?

代码解释：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head)
 {
     if(head==NULL)//首先判断头结点是否为空
     return NULL;//空就返回空
   struct ListNode* n1=NULL,*n2=head,*n3=n2->next;
   while(n2)//结束条件
   {
       n2->next=n1;//迭代过程
       n1=n2;
       n2=n3;
       if(n3)
       n3=n3->next;
   }
   return n1;
}

?

思路二头插法：

定义一个指针newHead指向空，cur指向头结点，next则是cur的下一个节点。接着再循环将cur的next指向newHead,newHead=cur,cur=next,当循环到cur=NULL时就结束。

?代码解释：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head)
 {
     struct ListNode* cur=head;
     struct ListNode* newHead=NULL;
     while(cur)//判断条件为cur!=NULL;
     {
         struct ListNode* next=cur->next;
         //头插
         cur->next=newHead;
         newHead=cur;
         cur=next;
     }
     return newHead;
}

二.链表的中间节点：

题目：

思路：快慢指针?

?代码解释：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head)
 {
    struct ListNode* slow=head,*fast=head;
    //如果快指针当前为空或下一个为空就跳出循环，分别对应奇数和偶数情况
    while(fast!=NULL && fast->next!=NULL)
    {//慢指针走一步快指针走两步
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

三.合并两个有序数组:?

题目：

?思路一：从头开始，取两个链表中小的那个尾插到新链表。定义指针head,tail指向空，代表新链表的头结点。

代码解释：?

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    if(list1==NULL)
    return list2;//如果其中一个链表为空就返回另一个
    if(list2==NULL)
    return list1;
    struct ListNode* head=NULL,*tail=NULL;
    while(list1 !=NULL && list2 !=NULL)//注意这里得返回条件是二者都不为空
    {
        if(list1->val < list2->val)//去取链表中小的那个进行尾插
        {
            if(tail==NULL)
            {
                head=tail=list1;
            }
            else 
            {
                tail->next=list1;
                tail=tail->next;
            }
            list1=list1->next;//取完后要将当前的指针后移一位
        }
        else
        {
            if(tail==NULL)
            {
                head=tail=list2;
            }
            else
            {
                tail->next=list2;
                tail=tail->next;
            }
            list2=list2->next;取完后要将当前的指针后移一位
        }
    }
    if(list1)//如果取完后其中一个不为空，就直接插入到新链表，原因是这两链表本就有序
    tail->next=list1;//剩下的必然比之前节点的数据大
    if(list2)
    tail->next=list2;
    return head;
}

思路二：创建一个空的头指针（哨兵位），优化代码?：

代码解释：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    if(list1==NULL)
    return list2;
    if(list2==NULL)
    return list1;
    struct ListNode* head=NULL,*tail=NULL;
    //创建一个哨兵位
    head=tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    while(list1!=NULL && list2!=NULL)
    {
        if(list1->val < list2->val)
        {
            tail->next=list1;
            list1=list1->next;
        }
        else
        {
            tail->next=list2;
            list2=list2->next;
        }
        tail=tail->next;
    }
    if(list1)
    tail->next=list1;
    if(list2)
    tail->next=list2;
    //存储第一个节点元素的位置，将哨兵位的空间释放
    struct ListNode* first=head->next;
    free(head);
    return first;//返回第一个节点
}

?四.环形链表①：

题目：?

思路： 快慢指针与追及，当快指针等于慢指针是，说明有环，否则无环

代码解释：?

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head)//bool类型返回正误
 {//定义一个快慢指针
    struct ListNode* fast=head,* slow=head;
    while(fast!=NULL && fast->next!=NULL)
    {//如果二者相遇，就返回ture，否则就返回false;
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        return true;
    }
    return false;
}

?五.环形链表②：

题目：

?思路：本题是求环的起始位置。运用快慢指针，先判断是否有环，接着根据路程可知慢指针是快指针速度的1/2，列出计算式可知，慢指针从head开始走x的距离时，fast在环中与slow相遇的位置距离环的起始位置为z,等于slow走过的距离。当二则再次相遇时，该点就是环的起始位置

图解：?

?

?代码解释：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode* fast=head,*slow=head;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(slow==fast)//先找到环中相遇点
        {
            slow=head;//slow的位置置于头，同时将slow和fast的书读都设为1
            while(slow!=fast)//二者必将相遇与开始入环的第一个节点
            {
                slow=slow->next;
                fast=fast->next;
            }
            return slow;
        }
    }
    return NULL;//如果找不到就返回空
}

博客到这里也是结束了，喜欢的小伙伴可以点赞加关注支持下博主，这对我真的很重要~~