借助递归实现链表指针的前移以及链表题目的一点小总结

链表不同于数组，知道一个节点，我们只能知道其后继节点，而不能知道其前驱节点，更无法直接移动到前驱节点

而由于递归可以通过压栈出栈来记录中间各节点，相当于依次将 链表节点压栈，然后需要时进行依次出栈，比如压栈顺序

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]