leetcode141_重排链表

一.迭代

1. 将链表转换为数组,然后用双指针分别取出头尾指针.

2. 相当于耍赖用数组转化链表.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //链表节点存数组.
    vector<ListNode*> tmp;
    void reorderList(ListNode* head) {
        if(head==NULL || head->next==NULL) return;
        while(head!=NULL) {
            tmp.push_back(head);
            head = head->next;
        }
        //头尾依次取出元素.
        int i=0, j=tmp.size()-1;
        while(i<j) {
            tmp[i]->next = tmp[j];
            i++;
            if(i==j) break;
            tmp[j]->next = tmp[i];
            j--;
        }
        //i和j无所谓,但是一定得指向NULL.
        tmp[i]->next = NULL;
        return;
    }
};

二. 递归

1. 这题最大的好处就是返回值为void. 这样我们不用返回头结点.

class Solution {
public:
    ListNode* helper(ListNode* head, int len) {
        //len更容易递归到终止条件.
        if(len==1) return head;
        if(len==2) return head->next;
        //返回head->next,len-2,即除去头尾节点的上一个
        //重排的尾部节点.
        ListNode* tail = helper(head->next, len-2);
        //画图容易理解.tmp为重排之前的最后一个节点.
        ListNode* tmp = tail->next;
        //头尾头尾顺序连接链表.
        //注意tail->next应该连接他之后的节点,
        //这样才能不停递归.
        tail->next = tail->next->next;
        tmp->next = head->next;
        head->next = tmp;
        //返回重排后链表的尾部节点.
        return tail;
    }
    void reorderList(ListNode* head) {
        if(head==NULL || head->next==NULL) return;
        int len = 0;
        ListNode* cur = head;
        while(cur!=NULL) {
            len++;
            cur = cur->next;
        }
        //helper函数的作用是给定头结点和对应的链表长度,
        //返回重排链表的最后一个节点.
        ListNode* tail = helper(head, len);
    }
};