C实现 LeetCode->Reorder List (双指针大法）(单链表是否有环)

/**

 *  Given a singly linked list L: L0→L1→…→Ln-1→Ln,

 reorder it to: L0→Ln→L1→Ln-1→L2→Ln-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}.

 

 

 分为四步。

 

 第一步找到链表长度。

 

 第二步把链表从中间分为两个子链表。

 

 第三步反转第二个子链表(ReverseLinkedList中的Reverse函数)。

 

 第四步把第二个子链表Merge到第一个子链表里面。

 */

//
//  ReorderList.c
//  Algorithms
//
//  Created by TTc on 15/6/22.
//  Copyright (c) 2015年 TTc. All rights reserved.
//
/**
 *  Given a singly linked list L: L0→L1→…→Ln-1→Ln,
 reorder it to: L0→Ln→L1→Ln-1→L2→Ln-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}.
 
 
 分为四步。
 
 第一步找到链表长度。
 
 第二步把链表从中间分为两个子链表。
 
 第三步反转第二个子链表(ReverseLinkedList 中的Reverse函数)。
 
 第四步把第二个子链表Merge到第一个子链表里面。
 */
#include "ReorderList.h"
#include <stdbool.h>
#include <stdlib.h>
#include "List.h"


/********************************************************************/
// LeetCode
/********************************************************************/

struct ListNode {
    int val;
    struct ListNode *next;
};


//双指针大法  链表反转函数(请背熟练)
/*Since only constant memory is allowed, time cost is O(k) */
static struct ListNode*
Reverse(struct ListNode *begin, struct ListNode *end){
    struct ListNode* prev = begin->next;
    struct ListNode* curr = prev->next;
    
    while(curr != end){
        prev->next = curr->next;
        curr->next = begin->next;
        begin->next = curr;
        curr = prev->next;
    }
    return prev;
}


void
reorderList(struct ListNode* head) {
    if (head == NULL)  return;
    
    //Step1:  第一步找到链表长度。
    struct ListNode *tmp = head;
    int len = 0;
    while (tmp != NULL) {
        tmp = tmp->next;
        ++len;
    }
    int num_insertion = (len-1)/2;
    
    //Step2:   第二步把链表从中间分为两个子链表。
    tmp = head;
    int count = 0;
    while (count < len-1-num_insertion) {
        tmp = tmp->next;
        ++count;
    }
    struct ListNode *second_half = tmp->next;
    tmp->next= NULL;
    
    //Step3:    第三步反转第二个子链表(ReverseLinkedList 中的Reverse函数)。
    if (second_half != NULL && second_half->next != NULL) {
        struct ListNode *dummyHead = (struct ListNode *)malloc(sizeof(*dummyHead));
        dummyHead->next = second_half;
        Reverse(dummyHead, NULL);
        second_half = dummyHead->next;
    }
    
    //Step4:    第四步把第二个子链表Merge到第一个子链表里面。（隔槽插入）
    struct ListNode *first_half = head;
    while (second_half != NULL) {
        struct ListNode *temp1 = second_half->next;
        second_half->next = first_half->next;
        first_half->next = second_half;
        second_half = temp1;
        first_half = first_half->next->next;
    }
}


/********************************************************************/
/********************************************************************/



/********************************************************************/
// List.c 是范性类 单链表
/********************************************************************/
//反转单链表中  begin  到 end 节点 (如果是反转整个 单链表 则需要传 0,list_size(),需要创建一个虚拟头节点)
static ListElmt*
tt_Reverse(ListElmt *begin, ListElmt *end){
    
    ListElmt* prev = begin->next;
    ListElmt* curr = prev->next;
    
    while(curr != end){
        prev->next = curr->next;
        curr->next = begin->next;
        begin->next = curr;
        curr = prev->next;
    }
    return prev;
}


void
tt_reorderList(ListElmt* head) {
    if (head == NULL)  return;
    
    //Step1:  第一步找到链表长度。
    ListElmt *tmp = head;
    int len = 0;
    while (tmp != NULL) {
        tmp = tmp->next;
        ++len;
    }
    int num_insertion = (len-1)/2;
    
    //Step2:   第二步把链表从中间分为两个子链表。
    tmp = head;
    int count = 0;
    while (count < len-1-num_insertion) {
        tmp = tmp->next;
        ++count;
    }
    ListElmt *second_half = tmp->next;
    tmp->next= NULL;
    printf("second_half======>%d\n", *(int *)second_half->data);
    print_listNode(second_half);


    //Step3:    第三步反转第二个子链表(ReverseLinkedList 中的Reverse函数)。
    if (second_half != NULL && second_half->next != NULL) {
        ListElmt *dummyHead = (ListElmt *)malloc(sizeof(*dummyHead));
        dummyHead->next = second_half;
        ListElmt * result = tt_Reverse(dummyHead, NULL);
        printf("result======>%d\n", *(int *)result->data);

        second_half = dummyHead->next;
        print_listNode(second_half);

    }
    
    //Step4:    第四步把第二个子链表Merge到第一个子链表里面。（隔槽插入）
    ListElmt *first_half = head;
    while (second_half != NULL) {
        ListElmt *temp1 = second_half->next;
        second_half->next = first_half->next;
        first_half->next = second_half;
        second_half = temp1;
        first_half = first_half->next->next;
    }
}

void
test_tt_reorderList(){
    List l1;
    list_init(&l1, free);
    int *data ;
    int array[15] = {10,9,8,7,6,5,4,3,2,1};
//    for (int i = 0; i< 10; i++) {
    for (int i = 0; i< 10; i++) {
        if ((data = (int *)malloc(sizeof(int))) == NULL)
            return ;
        *data = array[i];
        if (list_ins_next(&l1, NULL, data) != 0)  //逐个插入元素
            return;
    }
    print_list(&l1);
    tt_reorderList(list_head(&l1));
    printf("反转后*****************\n");
    print_listNode(list_head(&l1));
}