**24. 兩兩交換連結串列中的節點****19.刪除連結串列的倒數第N個節點****面試題 02.07. 連結串列相交****142.環形連結串列II**

24. 兩兩交換連結串列中的節點19.刪除連結串列的倒數第N個節點面試題 02.07. 連結串列相交142.環形連結串列II

24. 兩兩交換連結串列中的節點

題目地址 : 24. 兩兩交換連結串列中的節點 - 力扣（LeetCode）

Code :

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {

        //模組 化  處理  

        ListNode* pre = nullptr ;
        
        ListNode* p1 = head ; 
        ListNode* p2 = nullptr ;

        ListNode* Receive_NewLinkedListHead = nullptr ;


        if(head == nullptr )
        {
            return head ;

        }

        if(head -> next == nullptr )
        {
            return head ;

        }

        p2 = p1 -> next ;
        


        int FindAction = 0 ; // 觀察哨 

        while(p1 != nullptr  &&  p1->next != nullptr )
        {
            ListNode* next = p2->next ; // ( next , p->next  )  是否 為 空 指標 尚未 做 判斷  


            if(FindAction == 0 )        // 首次 處理  
            {                           // 第 一 組  結點  前  沒有  結點  （無 頭 連結串列  時  ）
                p1->next = next ;
                p2->next = p1 ;

                Receive_NewLinkedListHead = p2 ;


                FindAction = 1 ;

            }
            else
            {
                pre->next = p2;
                p1->next = next ;
                p2->next = p1 ;



            }

            if(next == nullptr )
            {
                break ;
            }

            if(next -> next == nullptr )
            {
                break;

            }

            //  注意  更新  連結串列  情況    

            
            pre = p1 ;

            p1 = next ;

            p2 = next -> next ;


        }

        // 結點 交換 處理  後邊  使用  的  是  相對 處理  /  支援 了  空指標 尾接  和  非空  結點  尾接    的   情況    


        return Receive_NewLinkedListHead ;


    }
};

19.刪除連結串列的倒數第N個節點

題目地址 : 19. 刪除連結串列的倒數第 N 個結點 - 力扣（LeetCode）

Code :

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        
        ListNode* pre = nullptr ;

        ListNode* p = head ;


        ListNode* ptr_Detector = nullptr ;

        int i;

        int Find_Detector = 0;


        if( head == nullptr )
        {
            return head ;

        }

        if( head -> next == nullptr && n == 1 )
        {
            return nullptr ;

        }

        ptr_Detector = head ;

        for(i = 0 ; ptr_Detector != nullptr && i < n ; i++)
        {
            ptr_Detector = ptr_Detector -> next ;

        }

    

        while( ptr_Detector != nullptr )
        {

            ptr_Detector = ptr_Detector -> next ;
            
            pre = p ;

            p = p -> next ;


            if(Find_Detector == 0)
            {

                Find_Detector = 1;
            }
            else
            {


            }



        }

        if(Find_Detector == 0)
        {
            head = head -> next ;

            return head ;

        }


        pre -> next = p -> next ;




        return head ;




    }
};

面試題 02.07. 連結串列相交

題目地址 : 面試題 02.07. 連結串列相交 - 力扣（LeetCode）

Code :

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

    //  長度   的   確定   ,   長度  的   difference 

    // 結點  的   匹配    

    int length_LinkedList1 = 0;
    int length_LinkedList2 = 0;

    ListNode * p1 = headA;
    ListNode * p2 = headB;


    int diff_Length ;


    while(p1 != nullptr )
    {

        length_LinkedList1 ++ ;


        p1 = p1 -> next ;

    }


    while(p2 != nullptr )
    {

        length_LinkedList2 ++ ;

        p2 = p2 -> next ;

    }


    p1 = headA;
    p2 = headB;


    diff_Length = length_LinkedList1 - length_LinkedList2 ;

    if(diff_Length >= 0 )
    {
        for(int i = 0 ; i < diff_Length ; i++ )
        {
            p1 = p1 -> next ;

        }

    }
    else
    {
        int abs_Diff_Length = abs(diff_Length);

        for(int i = 0 ; i < abs_Diff_Length ; i++ )
        {
            p2 = p2 -> next ;

        }

    }

    do
    {
        if(p1 == p2 )       // Check  地址  是否  一樣    
        {
            return p1 ;

        }

        // 不要 忘了 指標  的   移動    

        p1 = p1 -> next ;

        p2 = p2 -> next ;

                                    //    "這是   一道  側重  “ 積累 ”   的  題目 "


    }while(p1 != nullptr );



    return nullptr ;







    }
};

142.環形連結串列II

題目地址 : 142. 環形連結串列 II - 力扣（LeetCode）

Code :

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {

        // 不同 的 移動 速度 ?


        ListNode * p1 = head ;
        ListNode * p2 = head ;


        int diff_Pace = 0 ;


        


        do 
        {


            if(p1 == nullptr )
            {
                return nullptr ;

            }


            

            p1 = p1 -> next ;
            if(p1 == nullptr )
            {
                return nullptr ;

            }
            p1 = p1 -> next ;

            p2 = p2 -> next ;

            diff_Pace ++ ;

            if(p1 == p2 )
            {
                break;

            }


        }while(1) ;


        // Check  環 外  的  PaceDiff  和  環 內  的  PaceDiff    


        // 位置 的 使用 

        // ->  環 的 長度 

        int length_Cycle = 0 ;


        do 
        {
            p2 = p2 -> next ;
            length_Cycle ++ ;

        }while(p2 != p1 );



        ListNode * p3 = head ;
        ListNode * p4 = head ;



        for(int i = 0 ; i < length_Cycle ; i++ )
        {
            p3 = p3 -> next ;

        }


        while(p3 != p1)
        {
            p3 = p3 -> next ;
            p4 = p4 -> next ;

        }


        // 交點  判斷  ？


        do 
        {

            if(p4 == p2 )
            {
                return p2 ;

            }

            p4 = p4 -> next ;
            p2 = p2 -> next ;


        }while(1);






        
    }
};

注意首次處理的不同 , 注意對連結串列結點狀態的更新 , 注意對連結串列末尾的考慮 ,

指標的地址是可以進行比較的 (是否相等方面) , 注意不要忘了指標的移動 ,

二刷 , 對環形連結串列入口的尋找 ,

(自己主動) 疏通邏輯後 , 在沒有遇到其它較多的障礙 / 問題的情況下 , 就透過了

**24. 兩兩交換連結串列中的節點****19.刪除連結串列的倒數第N個節點****面試題 02.07. 連結串列相交****142.環形連結串列II**

24. 兩兩交換連結串列中的節點**19.刪除連結串列的倒數第N個節點面試題 02.07. 連結串列相交142.環形連結串列II**

24. 兩兩交換連結串列中的節點

19.刪除連結串列的倒數第N個節點

面試題 02.07. 連結串列相交

142.環形連結串列II

相關文章

24. 兩兩交換連結串列中的節點19.刪除連結串列的倒數第N個節點面試題 02.07. 連結串列相交142.環形連結串列II

24. 兩兩交換連結串列中的節點19.刪除連結串列的倒數第N個節點面試題 02.07. 連結串列相交142.環形連結串列II