快慢指针 - 关于链表oj题的思路延申

struct ListNode* middleNode(struct ListNode* head){
    
    struct ListNode* fase,*slow;

    fase = slow = head;

    while(fase && fase->next)//不清楚是奇数还是偶数
    {
        fase = fase->next->next;
        slow = slow->next;
    }
   
       return slow;
}

2.求链表中倒数第K个结点。oj习题

思路：定义一组快慢指针，fast为2倍的slow。此时fast从head的地址位置开始向后先访问k个结点，然后再一起向后访问，当fast访问到NULL，slow就是倒数第k个结点。

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    // write code here
    if(pListHead == NULL)
    {
        return NULL;
    }

       struct ListNode* fase,*slow;
       fase = slow = pListHead;

       while(k--)//先让fase先走k步
       {
           if(fase == NULL)//如果fase走到空，说明链表没有k步长
           {
               return NULL;
           }

          fase=fase->next;
       }
        
       while(fase)
       {
           fase = fase->next;
           slow = slow->next;
       }

       return slow;

    }

3.给定一个链表，判断链表中是否有环。oj习题

思路：定义一组快慢指针，fast为2倍的slow。两者同时从head的地址位置开始向后访问，当两者地址相等时，就证明链表中有环。反之当fast访问到NULL，两者的地址都不相等，则无环。

bool hasCycle(struct ListNode *head) {
    if(head == NULL)
    {
        return false;
    }

    struct ListNode *fast, *slow;
    fast = slow = head;

    while(fast && fast->next)//不清楚是否带环，链表是否奇偶
    {
        fast = fast->next->next;
        slow = slow->next;

        if(slow == fast)
             return true;
    }

    return false;
    
}

4.给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。oj习题

思路：定义一组快慢指针，fast为2倍的slow。

方法①. 运用4.思考一个指针从头指针的位置开始向后访问，一个指针从快慢指针相遇的地方开始向后访问，两个指针会在入环的第一个结点相遇。

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast, *slow;
    fast = slow = head;

    while(fast && fast->next)//不清楚是否带环，链表是否奇偶
    {
        fast = fast->next->next;
        slow = slow->next;

        if(slow == fast)
        {
            struct ListNode* meet = slow;//此时slow == fast == meet
            while(meet != head)
            {
                meet = meet -> next;
                head = head ->next;
            }

            return meet;//此时meet == head 就是入环的第一个结点
        }
             
    }

    return NULL;  
}

方法②.创建一个指针从meet位置的下一个结点开始向后访问，求两个链表相交的交点。（如下图所示）

这里需要考虑一个特殊情况，如果meet == head怎么办？

struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode* fast, * slow;
    fast = slow = head;

    while (fast && fast->next)
    {
        //快慢指针同时向后开始访问
        fast = fast->next->next;
        slow = slow->next;

        //如果它们访问的地址相同，那么这个结点就是快慢指针相遇点
        if (slow == fast)
        {
            struct ListNode* meet = slow;

            if (head == meet)//如果head等于快慢指针相遇结点，就证明头指针就是入环的第一个结点
            {
                return head;
            }

            struct ListNode* curA = head, * curB = meet->next;

            int lenA = 1, lenB = 1; //求长度，从1开始，不然尾结点会漏掉


            while (curA->next != meet)
            {
                curA = curA->next;
                lenA++;
            }

            while (curB->next != meet)
            {
                curB = curB->next;
                lenB++;
            }

            //此时curA,curB都是尾结点

            //求第一个交点

             //假设A短B长
            struct ListNode* shortList = head, * longList = meet->next;
            //修正 如果A长B短，则交换彼此变量
            if (lenA > lenB)
            {
                shortList = meet->next;
                longList = head;
            }

            //差距
            int gap = abs(lenA - lenB);//abs求绝对值

            while (gap--) //长的先走差距步
            {
                longList = longList->next;
            }

            //同时走
            while (shortList != longList)
            {
                shortList = shortList->next;
                longList = longList->next;
            }


            //到这里肯定相等，返回 shortList / longList 都可以。

            return shortList;

        }
    }

    return NULL;//如果fast访问到NULL即证明无环
}

快慢指针 - 关于链表oj题的思路延申

猜你喜欢