藉助遞歸實現鏈表指針的前移以及鏈表題目的一點小總結

鏈表不同於數組，知道一個節點，我們只能知道其後繼節點，而不能知道其前驅節點，更無法直接移動到前驅節點

而由於遞歸可以通過壓棧出棧來記錄中間各節點，相當於依次將 鏈表節點壓棧，然後需要時進行依次出棧，比如壓棧順序

a,b,c,d，則出棧順序爲 d,c,b,a,以此來模擬鏈表指針的回溯

下面通過例子來進行說明：

1.給定一個單鏈表，判斷該鏈表是否屬於迴文結構

如果給定的是一個數組，那麼該題很簡單，採用雙指針法，一個向前，一個向後，進行比較，比較結果相等則繼續，不等則立刻返回false

所以我們考慮採用的辦法，即雙指針法，重點是如何實現第二個指針的向前遍歷

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) 
    {
        left = head;
        ListNode* right = head;
        return recurse(right);
        
    }
private: 
    ListNode* left; //第一個指針，爲了不讓其受遞歸影響，所以設置爲成員變量，便於操作
    bool recurse(ListNode* right)
    {
        if(right == NULL)//如果是空鏈表，則認爲是滿足迴文結構
        {
            return true;
        }
        bool isPal = recurse(right->next);//進行遞歸，找到最後一個節點，此時最後一個節點是用right表示的，然後開始回溯，即出棧過程
        if(left -> val != right ->val)
        {
            return false;
        }
        
        //要手動移動left
        left = left->next;
        return isPal;
    }
};

2.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) 
    {
        flag = true;
        left = head;
        ListNode* right = head;
        recurse(right, m, n);
        return head;
    }
private:
    ListNode* left;//第一個指針
    bool flag;
    
    void recurse(ListNode* right,int m,int n)
    {
        if(n == 1)
        {
            return;
        }
        right = right->next;
        if(m > 1)
        {
            left = left->next;
        }
        recurse(right,m-1,n-1);//將第二個指針遞歸移動到第n個節點中
        if(left == right || right->next == left)//兩個指針數據交換停止條件
        {
            flag = false;
        }
        if(flag)//之所以引入flag，是因爲當flag爲false時，遞歸並不會因此而停止，它還是要進行回溯，直到其初始位置
        {
            int tmp = left->val;
            left->val = right->val;
            right->val = tmp;
            left = left->next;
        }

        return;
    }
    
};

3.對鏈表題目的一點小總結

關於鏈表的反轉，可以用遞歸實現，而且比較直觀簡單，當然也可以用迭代

迭代反轉要記住，要想富，先修路；要想反轉，先記後繼，輪迴不止（即先記錄下當前節點的後繼節點，然後改變當前節點的後繼爲前驅，前驅pre變爲當前節點，當前節點變爲後繼節點）

after = cur->next;

cur->next = pre;

pre = cur;

cur = after;

如何知道鏈表的中間節點呢，雙指針法，一個快指針，一次走兩步，一個慢指針，一次走一步，當快指針不能繼續向前走的時候，慢指針基本到達了鏈表中點，再稍微調整即可

判斷鏈表是否有環，雙指針追趕法

鏈表的排序可以採用歸併排序，先從1開始進行，然後從2，到4,8.。。。

以下爲代碼，方便忘了以後複習：

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

//歸併排序
class Solution {
public:
    ListNode* sortList(ListNode* head) 
    {
        if(head == NULL || head->next == NULL)
        {
            return head;
        }
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* tail = dummy;
        int len = 0;
        ListNode* tmp = head;
        while(tmp)
        {
            len++;
            tmp = tmp->next;
        }
        
        
        //歸併排序
        for(int step = 1; step < len; step <<= 1 ) 
        {
            ListNode* cur  = dummy->next;
            tail = dummy;
            while(cur)
            {
                ListNode* left = cur;
                ListNode* right = split(left,step);
                cur = split(right,step);
                tail = merge(left, right, tail);
            }
        }
        return dummy->next;
    }
private:
    ListNode* split(ListNode* head,int step)//按step對鏈表進行分割，第一個自戀吧長度爲step,返回的是第二個子鏈表的頭指針
    {
        while(step > 1 && head != NULL)
        {
            head = head->next;
            step--;
        }
        if(head == NULL)
        {
            return NULL;
        }
        ListNode* secondhead = head->next;
        head->next =NULL;
        return secondhead;
    }
    ListNode* merge(ListNode* left, ListNode* right, ListNode* tail) //返回歸併後的尾結點，以方便連接其他順序鏈表的歸併結果
    {
        ListNode* cur = tail;
        while(left && right)
        {
            if(left->val >= right->val)
            {
                cur->next = right;
                cur = right;
                right = right->next;
            }
            else
            {
                cur->next = left;
                cur = left;
                left = left->next;
            }
        }
        cur->next = left ? left : right;
        
        while(cur->next)
        {
            cur = cur->next;
        }
        return cur;
    }
    
    
    
    
};

以例子 

-1->5->3->4->0 進行說明

鏈表初始狀態	step	子鏈表狀態	子鏈表歸併後狀態
[-1,5,3,4,0]	1	[-1],[5],[3],[4],[0]	[-1,5],[3,4],[0]
[-1,5,3,4,0]	2	[-1,5],[3,4],[0]	[-1,3,4,5],[0]
[-1,3,4,5,0]	4	[-1,3,4,5],[0]	[-1,0,3,4,5]

 最後結果爲 [-1,0,3,4,5]