合并两个有序的子序，要求空间复杂度为O(1)

百度2012实习生校园招聘笔试题

数组al[0,mid-1]和al[mid,num-1]是各自有序的，对数组al[0,num-1]的两个子有序段进行merge，得到al[0,num-1]整体有序。要求空间复杂度为O(1)。注：al[i]元素是支持'<'运算符的。

先是琢磨良久，是否可能时间复杂度为O(n)，因为这让我想起了，左旋转数组的相关的算法。深陷下去后，突然什么光一闪。。。

果断放弃，使用最简单的算法，几分钟笔墨，错改调。（上次就是如此深陷泥潭而不可自拔）：

void swap(int *a, int *b)
{
    int tmp;

    tmp = *a;
    *a = *b;
    *b = tmp;
}

void func(int a[], int n)
{
    int i,j;

    if (n<=0)
    {
        return;
    }
    i = 0;
    j = n/2;

    while(j<n && i<j)
    {
        if (a[i]<=a[j])
        {
            i++;
        }
        else
        {
            swap(a[i], a[j]);
            for (int k=j-1;k>i; k--)
            {
                swap(a[k], a[k+1]);
            }
            i++;
            j++;
        }
    }

}

算法简单，最坏的时间复杂度为O(n^2)。 

 

红色的区域是已排好的，绿色为前一子序，紫红为后子序；比较前后子序的最小元素，小的放入红色区域。

如果i的小，只需要往前一步；否则i与j的元素互换，各自向前一步；但此时导致前子序不再有序，通过调整恢复有序即可；

接着又网上搜索工作，找到一个block swapping。懒得看完，但却给了我提示，算法可以优化；

之前所说的调整恢复其实就是一个右移了一位，每当j中有元素较小时，就需要前移到红色区域中，这样导致了要移位；

试想j的后面有几个连续的元素都比i 小，这样每次就会导致j-i个移动元素；所以改动一下，没有每次都移动，等到j开始比i大的时候，

才开始移位，这时应用之前的“左移k的算法（貌似就是block swapping）”，其实时间复杂度为O(n)，所以当j连续比i小的数很多，效率就比较高了。

例如：1 6 9 12 2 3 4 15

1、i=0；j=4；a[i]<a[j] 所以i++

2、i=1; j=4; a[i]>a[j] 所以交换为 1 2 9 12 6 3 4 15; i++;j++

3、i=2; j=5; a[i]>a[j] 所以交换为 1 2 3 12 6 9 4 15; i++; j++

4、i=3; j=6; a[i]<a[j] 已经a[j]开始小了，1 2 3 12 6 9 4 15，所以这时蓝色部分就要一次右移两位（两个连续的小），移位后1 2 3 6 9 12 4 15

5、之后，沿袭刚才的思想，继续下去。。。

这样只是稍微的优化一下而已。又是一番折腾

void reverse(int a[], int i, int j)
{

    if (j-i<1)
    {
        return;
    }
    for (;i<j; i++,j--)
    {
        swap(&a[i], &a[j]);
    }
}

void rightmove(int a[], int i, int j, int k)
{
    if (j-i<1)
    {
        return;
    }

    reverse(a, i, j-k);
    reverse(a, j-k+1, j);
    reverse(a, i, j);
}

void func1(int a[], int n)
{
    int i,j,tmp;
    i=0;
    j = n/2;
    while(i<j&& j<n)
    {
        tmp = j;
        while(i<j && a[i]<=a[j])
        {
            i++;
        }
        while(i<j && a[j]< a[i])
        {            
            swap(&a[i], &a[j]);
            j++;
        }

        rightmove(a, i+1, j-1, j-tmp);
        i++;
    }
}

结果看了看标准答案，华丽地把哥的秒了：

/*
数组a[begin, mid] 和 a[mid+1, end]是各自有序的，对两个子段进行Merge得到a[begin , end]的有序数组。 要求空间复杂度为O(1)
方案：
1、两个有序段位A和B，A在前，B紧接在A后面，找到A的第一个大于B[0]的数A[i]， A[0...i-1]相当于merge后的有效段，在B中找到第一个大于A[i]的数B[j]，
对数组A[i...j-1]循环右移j-k位，使A[i...j-1]数组的前面部分有序
2、如此循环merge
3、循环右移通过先子段反转再整体反转的方式进行，复杂度是O(L), L是需要循环移动的子段的长度
*/
#include<iostream>
using namespace std;

void Reverse(int *a , int begin , int end )   //反转
{
    for(; begin < end; begin++ , end--)
        swap(a[begin] , a[end]);
}
void RotateRight(int *a , int begin , int end , int k)    //循环右移
{
    int len = end - begin + 1;  //数组的长度
    k %= len;
    Reverse(a , begin , end - k);
    Reverse(a , end - k + 1 , end);
    Reverse(a , begin , end);
}

// 将有序数组a[begin...mid] 和 a[mid+1...end] 进行归并排序
void Merge(int *a , int begin , int end )
{
    int i , j , k;
    i = begin;
    j = 1 + ((begin + end)>>1);    //位运算的优先级比较低，外面需要加一个括号，刚开始忘记添加括号，导致错了很多次
    while(i <= end && j <= end && i<j)
    {
        while(i <= end && a[i] < a[j])
            i++;
        k = j;   //暂时保存指针j的位置
        while(j <= end && a[j] < a[i])
            j++;
        if(j > k)
            RotateRight(a , i , j-1 , j-k);   //数组a[i...j-1]循环右移j-k次
        i += (j-k+1);  //第一个指针往后移动，因为循环右移后，数组a[i....i+j-k]是有序的
    }
}

void MergeSort(int *a , int begin , int end )
{
    if(begin == end)
        return ;
    int mid = (begin + end)>>1;
    MergeSort(a , begin , mid);   //递归地将a[begin...mid] 归并为有序的数组
    MergeSort(a , mid+1 , end);   //递归地将a[mid+1...end] 归并为有序的数组
    Merge(a , begin , end);       //将有序数组a[begin...mid] 和 a[mid+1...end] 进行归并排序
}

int main(void)
{
    int n , i ;
    //    int a[] = {1, 5,6,7,15,66, 2,3,4,8,33,35};
    int a[] = {1 ,6 ,9 , 2 ,3,4 ,15};
    
    n = sizeof(a)/sizeof(int);
    
    MergeSort(a , 0 , n - 1);
    
    for(i = 0 ; i < n ; ++i)
        cout<<a[i]<<" ";
    
    return 0;
}

咋一看，和哥的像，太像了；可是算法的思想的是两码事。（思考：1 3 5 7 2 4 6 8,我的算法则将要退化）

答案的思想高明要与结合了，归并（分治）的思想。继续考虑刚才的例子：

1 6 9 12 2 3 4 15

1、递归到底，将数组分每个元素为一个子序列，显然有序

2、退上一层，两个一组，1 6 | 9 12 | 2 3 | 4 15，依然有序

3、退上一层，四个一组，1 6 9 12 | 2 3 4 15

4、退上一层，8个一组，1 2 3 4 6 12 15

坑爹啊~这不是和哥的算法一样么。。。。其实是这样的当只有偶数个的时候，就退化为第二个算法了。

因为其每次的分组刚好是有序的，只有退回至最上层的时候，才需要真正移位。

再考虑 1 ,6 ,9 , 2 ,3,4 ,15

1、递归到底，将数组分每个元素为一个子序列，显然有序

2、退上一层，两个一组，1 6 | 9  2 | 3 4 | 15=>1 6 | 2 9 | 3 4 | 15

3、退上一层，四个一组，1 2 6 9 | 3 4 15

4、退上一层，7个一组，1 2 3 4 6 9 15

其实回想起来，没见得算法三很好，而且使用了两个递归。至于效率上，隐约感觉算法三稍比算法二的好；

毕