reorder-list(leetcode)

题目描述

Given a singly linked list L: L 0→L 1→…→L n-1→L n,
reorder it to: L 0→L n →L 1→L n-1→L 2→L n-2→…

You must do this in-place without altering the nodes’ values.

For example,

Given{1,2,3,4}
reorder it to{1,4,2,3}.

结果

1. 先将每个节点的都存在向量中，接着遍历一遍列表，对奇数节点从向量尾部取值并赋值，偶数节点，从向量正向取值

/**
 1. Definition for singly-linked list.
 2. struct ListNode {
 3.     int val;
 4.     ListNode *next;
 5.     ListNode(int x) : val(x), next(NULL) {}
 6. };
 */
class Solution {
public:
    void reorderList(ListNode *head) {
        if(!head || !head->next)
            return;
        ListNode *p=head;
        vector<int> Vec;
        while(p)
        {
            Vec.push_back(p->val);
            p = p->next;
        }
        int i=0, count = 1, j=Vec.size()-1;
        p = head;
        while(p)
        {
            if(count%2)
            {
                p->val = Vec[i];
                i++;
            }
            else{
                p->val = Vec[j];
                j--;
            }
            p = p->next;
            ++count;
        }
        }
};

2. 拆分链表，后一个链表逆转，拼接

  /**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    public void reorderList(ListNode head) {
        if(head==null || head.next==null)
            return;
        //快慢指针找中点
        ListNode fast = head;
        ListNode slow = head;
        while(fast.next!=null && fast.next.next!=null)
        {
            fast = fast.next.next;
            slow = slow.next;
        }
        
          // 拆分链表，并反转中间节点之后的链表
        ListNode after = slow.next;
        slow.next = null;
        ListNode pre = null;
        while(after != null){
            ListNode temp = after.next;
            after.next = pre;
            pre = after;
            after = temp;
        }
        // 合并两个链表
        ListNode first = head;
        after = pre;
        while(first != null && after != null){
            ListNode ftemp = first.next;
            ListNode aftemp = after.next;
            first.next = after;
            first = ftemp;
            after.next = first;        
            after = aftemp;        
        }
    }

}