交換兩個子數組的位置（只使用1個輔助空間）

一、問題描述

其實這是一個非常基本和常用的數組操作，它的描述如下：

有一數組X[0...n-1],現在把它發爲兩個子數組x1[0...m]和x2[m+1...n-1]，交換這兩個子數組，使用數組x由x1x2變成x2x1，例如x={1，2，3，4，5，6，7，8，9}，x1={1，2，3，4，5}，x2={6，7，8，9}，交換後，x={6，7，8，9，1，2，3，4，5}。

二、解題思路

1、蠻力法

第一個想到的辦法當然是用new或malloc開闢一個與其中一個子數組（如第一個子數組x1）大小的數組，並把此子數組的內容複雜到新開闢的數組中，然後把第二個數組x2的內容放到數組x的前面，再加新數組的內容（即x1的內容）複製到數組x的後面，所以空間複雜爲O(n)，要掃描數組2次，即時間複雜度爲O(N)。

2、平行移動法

這個方法有點類似於字符串的平行移動，這裏以向左移動爲例，我們可以把數組看成是環形的，每次用一個變量記錄數組的第一個元素x[0]，把數組的全部元素向左移動一個單位，並把用變量記錄的數據（即原先的x[0]）放到數組的最後一個位置。如此循環第一個子數組的元素的個數次，即把第一個子數組x1的元素全部移動到後面，就能把兩個子數組交換。因爲只用到了一個變量保存x[0]，所以空間複雜度爲O(1)，而要把數組中的每個元素都移動第一個子數組的元素的個數次，設原數組的元素個數爲N，則時間複雜度爲O(N*(x1/x)*N) = O(N^2)。

3、分治法

既然我們不能一次把兩個子數組交換，那麼就先把分別兩個子數組的內容交換，然後把整個數組的內容交換，即可得到問題的解，而交換兩個變量的值，只需要使用一個輔助儲存空間。其實這個非常好證明，就用上面的例子，自己算一算即可，證明如下：

交換兩個數組後，x1={5，4，3，2，1}，x2={9，8，7，6}，即x={5，4，3，2，1，9，8，7，6}

交換整個數組後，x={6，7，8，9，1，2，3，4，5}

所以，空間複雜度爲O(1)，掃描了兩次數組，時間複雜度爲O(n)。

三、代碼實現

這裏給出了第三種方法的實現代碼，考慮到代碼的通用性，使用了模板函數，如果看不懂模板函數，則只需要忽略template<typename T>，並把T看作是一個類型即可。代碼如下：

template<typename T>
void SwapSubArray(T *array, int array_size, int div);


template<typename T>
void Swap(T *array, int left, int right);


template<typename T>
void SwapSubArray(T *array, int array_size, int div)
{
    //首先交換第一個子數組的內容
    Swap(array, 0, div);
    //再交換第二個子數組的內容
    Swap(array, div+1, array_size-1);
    //交換整個數組的元素
    Swap(array, 0, array_size-1);
}


template<typename T>
void Swap(T *array, int left, int right)
{
    //交換數組left到right的內容
    for(; left < right; ++left, --right)
    {
        T tmp = array[left];
        array[left] = array[right];
        array[right] = tmp;
    }
}

測試代碼如下：

#include <iostream>
#include "swap_subarray.h"

using namespace std;

int main()
{
    int a[9] = {1,2,3,4,5,6,7,8,9};
    SwapSubArray(a, 9, 4);
    for(int i = 0; i < 9; ++i)
        cout << a[i];
    return 0;
}

運行結果如下：