LeetCode 148. Sort List 解题报告(归并排序小结)

leetcode 148. Sort List

提交网址： https://leetcode.com/problems/sort-list/ 

Total Accepted: 68702 Total Submissions: 278100 Difficulty: Medium  ACrate: 24.7%

Sort a linked list in O(n log n) time using constant space complexity.

由于需要使用常量空间，即S(n)=O(1)，故需要使用归并排序去解决此问题，下面采用二路归并来解题.

二路归并排序其实要做两件事,：

(1)“分解”——将序列每次折半划分。

(2)“合并”——将划分后的序列段两两合并后排序。

自顶向下的归并排序(递归)：采用分治法进行自顶向下的程序设计方式，分治法的核心思想就是分解、求解、合并。

1) If head == NULL or 只有一个元素
    return head.

2) else 将链表分为两个部分，  
      pSlow是中点; /* pFast, pSlow指针找到中点 */

3) 分别对front,back排序
      sortList(head); // 前半段
      sortList(pSlow->next); // 后半段

4) 合并已排序的front, back
      merge(*pFront, *pBack);

单链表递归实现 自顶向下

AC代码：

#include <iostream>using namespace std;struct ListNode {      int val;      ListNode *next;      ListNode(int x) : val(x), next(NULL) {}}; class Solution {public:    ListNode* sortList(ListNode* head) {        ListNode *pFast, *pSlow,*pFront,*pBack;        pFast=head;        pSlow=head;        if(head==NULL || head->next==NULL) return head;        else {        while(pFast->next!=NULL && pFast->next->next!=NULL)        {            pFast=pFast->next->next;            pSlow=pSlow->next;             //快慢指针找到中间节点，当快指针到末尾，慢指针恰好到中点        }// 从中间结点断开，中间结点的next域置为NULL，中间结点及其以前的部分为前半段，中间结点后一个节点到最后为后半段                pFast=pSlow;        pSlow=pSlow->next;        pFast->next=NULL;        pFront=sortList(head);           // 递归地排序前半段        pBack=sortList(pSlow);          // 递归地排序后半段        return merge(pFront,pBack); // 合并前后两段序列    }}        ListNode* merge(ListNode* head1, ListNode *head2)  //  将两个已经有序的序列进行合并    {          ListNode *res, *p;         if(head1==NULL) return head2;        if(head2==NULL) return head1;            if(head1->val < head2->val)                {                    res=head1;          // 结点需要整体赋值，不能只给val属性赋值                    head1=head1->next;                }            else {                    res=head2;                    head2=head2->next;                           }            p=res;            while(head1!=NULL && head2!=NULL)            {                if(head1->val < head2->val)                {                    p->next=head1;                    head1=head1->next;                }                else {                    p->next=head2;                    head2=head2->next;                }            p=p->next;                }         if(head1!=NULL) p->next=head1;        // 挂接上去         else if(head2!=NULL) p->next=head2;         return res;     }};// 以下为测试部分/*   int main(){ListNode *pOut;ListNode *head=new ListNode(5);head->next=new ListNode(8);head->next->next=new ListNode(7);head->next->next->next=new ListNode(12);head->next->next->next->next=new ListNode(4);Solution sol;pOut=sol.sortList(head);while(pOut!=NULL){cout<<pOut->val<<" ";pOut=pOut->next;}cout<<endl;return 0;}*/

链表 非递归实现 自底向上 

非递归实现的思想和递归正好相反，原来的递归过程是将待排序集合一分为二，直至排序集合就剩下一个元素位置，然后不断的合并两个排好序的数组。所以非递归思想为，将数组中的相邻元素两两配对。用merge函数将他们排序，构成n/2组长度gap为2的排序好的子数组段，然后再将他们排序成长度为4的子数组段，如此继续下去，直至整个数组排好序。

先将1+1(gap=1)个只有1个结点的链表按二路归并的方法加到tail结点的后面，然后更新tail；接着将2+2(gap=2)个分别有序的链表按二路归并的方式加到当前tail结点的后面，然后更新tail；gap每次扩大2倍，直到从split()函数(从head结点开始分离出长度为gap的链表)的返回值为NULL时结束外层循环。

例如： 下图是6 10 9 5 3 11 4 8 1 2 7的自底向上的归并过程...

链表 非递归

AC代码：

// To-Do: 链表非递归实现，自底向上 #include <iostream>using namespace std;struct ListNode{    int val;    ListNode *next;    ListNode(int x): val(x), next(NULL) {}};class Solution {public:    ListNode *split(ListNode *head, int size) // 从head结点开始分离出长度为size的链表，并将第size-1个结点的next置为NULL，返回剩下的链表     {         for(int i = 1; i < size; i++)        {           if(head != NULL) head=head->next;  // 从head结点开始分离出长度为size的链表，分离前总长度>size时，可以顺利到结尾，如果不足size，剩下的链表为NULL，分离到的长度为实际长度(<size的某值)             }        if(head == NULL) return NULL;                    ListNode *p = head->next;        head->next = NULL;        return p;    }       ListNode* merge(ListNode *head1, ListNode *head2, ListNode *tail)  // tail始终指向已合并链表的末尾，tail之后的结点值是有序的     {        while(head1 && head2)   // head1、head2均不为NULL时         {            if(head1->val < head2->val)  // 将值较小的结点挂到tail之后            {                tail->next = head1;      // head1的值较小，将该结点挂到tail后                 tail = tail->next;                head1 = head1->next;            }            else {                tail->next = head2;      // head2的值较小，将该结点挂到tail后                 tail = tail->next;                head2 = head2->next;            }        }        tail->next = (head1 == NULL) ? head2 : head1;         // 如果head1先为空，即head1对应的链表较短时，把head2剩下的那些结点挂到tail后面; 反之同理，同时为NULL时皆可         while(tail->next != NULL)            tail = tail->next;        return tail;    }        ListNode* sortList(ListNode* head)    {        if(head == NULL || head->next == NULL)            return head;                 int len = 0;        ListNode *cur = head;        while(cur)        {            len ++;            cur = cur->next;        }                ListNode *front, *back;                ListNode *pTemp = new ListNode(0);  //pTemp保存临时更小的那个节点        ListNode *tail = pTemp;                 pTemp->next = head;                      // 将head挂到pTemp之后         for(int size = 1; size < len; size <<= 1)  // 每次归并都分两路，链表的宽度的初始值为1,(2,4,8,....)，size*2         {            cur = pTemp->next;            tail = pTemp;            while(cur) // 当前结点后面还有结点时继续循环             {                front = cur;                back = split(cur, size);    //从当前结点向后分离出size长的链表front                cur = split(back, size);    //从当前结点向后分离出size长的链表back                  tail = merge(front, back, tail);  // 将front链表、back链表以二路归并的方式加到tail后去             }            }        return pTemp->next;    }};// 以下为测试   int main() {    Solution sol;       ListNode *pOut;     ListNode *head=new ListNode(5);     head->next=new ListNode(8);     head->next->next=new ListNode(7);     head->next->next->next=new ListNode(12);     head->next->next->next->next=new ListNode(-3);         pOut=sol.sortList(head);          while(pOut!=NULL)     {         cout<<pOut->val<<" ";         pOut=pOut->next;     }     cout<<endl;     return 0; }

数组 递归实现：

#include <cstdio>using namespace std;void Merge(int arr[], int left, int right, int mid) {    //归并操作    int length = right - left + 1;    int beginA = left, beginB = mid + 1;  //设置两个标志，分别指向两个已排序序列的起始位置    int i, j = 0;    int *pArr = new int[length];  // 创建临时辅助数组    //     if (pArr == NULL)  {  printf("Memory allocated error\n"); return;  }    while(beginA <= mid)    {        if(arr[beginA] > arr[beginB])  pArr[j++] = arr[beginB++];        if(arr[beginA] < arr[beginB])  pArr[j++] = arr[beginA++];        if(beginB > right) break;    }    while(beginA <= mid) pArr[j++] = arr[beginA++];   //将小元素添加到辅助数组    while(beginB <= right) pArr[j++] = arr[beginB++]; //同上    for(i = 0; i < length; i++)  arr[left++] = pArr[i]; //把排序好的部分移回arr数组中    delete[] pArr;   // 释放辅助数组}void mergeSort(int arr[], int left, int right){    //对数组递归地进行二路归并    int mid =(left + right)/2;    if(left >= right) return;    mergeSort(arr,left, mid);          //递归的归并排序左边    mergeSort(arr, mid+1, right);      //递归的归并排序左边    Merge(arr,left,right,mid);         //合并}int main(){    int arr[]={5,2,6,3,9,10,8};    int len = sizeof(arr)/sizeof(int);    mergeSort(arr,0,len-1);    for(int i = 0; i <= len-1; i++) {        printf("%d ",arr[i]);    }    return 0;}

数组 非递归实现：

#include <cstdio>using namespace std;// 将数组中连续的两个子序列合并为一个有序序列void Merge(int* arr, int *tempArr, int bIndex, int mIndex, int eIndex){int gap = eIndex - bIndex;    //合并后的序列长度int i = 0;         //记录合并后序列插入数据的偏移int j = bIndex;    //记录子序列1插入数据的偏移int k = mIndex;    //记录子序列2插入数据的偏移while(j < mIndex && k < eIndex){if(arr[j] <= arr[k]){tempArr[i++] = arr[j];j++;}else{tempArr[i++] = arr[k];k++;}}if(j == mIndex)    //说明序列1已经插入完毕{while(k < eIndex)tempArr[i++] = arr[k++];} else {             //说明序列2已经插入完毕while(j < mIndex)tempArr[i++] = arr[j++];} for(i = 0; i < gap; i++)    //将合并后序列重新放入arrarr[bIndex + i] = tempArr[i];}// 自底向上的归并排序(非递归)void mergeSort(int* arr, int len){int *tempArr = new int[len];    //临时存放合并后的序列int gap = 1;    //初始有序子序列长度为1while(gap < len){int i = 0;for(; i + 2*gap < len; i += 2*gap)Merge(arr, tempArr, i, i + gap, i + 2*gap);if(i + gap < len)Merge(arr, tempArr, i, i + gap, len);gap *= 2;    //有序子序列长度*2}delete[] tempArr;}// 以下为测试 int main(){    int arr[]={5,2,6,3,9,10,8};    int len = sizeof(arr)/sizeof(int);    mergeSort(arr, len);    for(int i = 0; i <= len-1; i++) {        printf("%d ",arr[i]);    }    return 0;}

另外，如果要进行原址归并，不占用其他空间，编程珠玑上提出了一个很神奇的算法，代码如下：

#include<cstdio>using namespace std;//此函数用于一个反转数组void reverse(int arr[], size_t size){    int left = 0,        right = size - 1,        tmp = 0;    while(left < right)    {        tmp = arr[left];        arr[left] = arr[right];        arr[right] = tmp;        left++;        right--;    }}//手摇法 通过三次反转操作交换两个子序列的位置，两个子序列内部的排序不变。void swap_blocks(int arr[], size_t size, size_t lft_size) {    reverse(arr, lft_size);    reverse(arr + lft_size, size - lft_size);    reverse(arr, size);}void in_place_merge(int arr[], size_t size, size_t mid) //原地归并{    size_t lft_s = 0, rit_s = mid, rmove;     while (lft_s < rit_s && rit_s < size)    {        while (lft_s < rit_s && arr[lft_s] <= arr[rit_s])        {            lft_s++;        }        rmove = 0;        while (rit_s < size && arr[lft_s] > arr[rit_s])        {            rmove++;            rit_s++;        }        swap_blocks(arr + lft_s, rit_s - lft_s, rit_s - lft_s - rmove);        lft_s += rmove;    }}int main(){    int arr[]={5,2,6,3,9,10,8};    int len = sizeof(arr)/sizeof(int);    in_place_merge(arr,0,len-1);    for(int i = 0; i <= len-1; i++) {        printf("%d ",arr[i]);    }    return 0;}

相关链接：
自顶向下的归并排序 - 太阳落雨 - CSDN http://blog.csdn.net/cjf_iceking/article/details/7921443

自底向上的归并排序 - 太阳落雨 - CSDN http://blog.csdn.net/cjf_iceking/article/details/7920153

归并排序(递归实现+非递归实现+自然合并排序) - geeker - 博客园 http://www.cnblogs.com/liushang0419/archive/2011/09/19/2181476.html