重新排列包含正数和负数的数组

给定一个包含正数和负数的整数数组，重新排列它，使得所有的负数排在前面，所有的正数排在后面。正数间和负数间的相对顺序保持不变。期望时间复杂度是O(n), 空间复杂度是O(1).

例如: 给定 [-1,2,-2,3,5,-4], 重新排列后变成 [-1,-2,-4,2,3,5]

分析： 1. 最简单的算法是O(n^2), 遇到每个负数都把它移动到数组前面已经排列好的负数部分后面。

2. O(n)的算法暂时没想出来，似乎比较难，下面给出一个O(nlogn)的算法。基本思想类似于Merge Sort. 空间复杂度由于用到递归，是O(logn). 不过可以很容易改写为bottom-up的迭代版本。

void Main()
{
int[] nums = new int[] {-1, 2, -2, 3, 5, -4};

Reorder(nums, 0, nums.Length-1);
}

// Define other methods and classes here
public void Reorder(int[] nums, int start, int end)
{
if(start >= end) {
return;
}

int middle = start + (end-start)/2;
Reorder(nums, start, middle);
Reorder(nums, middle+1, end);
Merge(nums, start, middle, end);
}

private void Merge(int[] nums, int start, int end)
{
int i = start;
while(nums[i] < 0 && i <= end) i++;
int j = end;
while(nums[j] >= 0 && j >= start) j--;

// Shift the negative part to the front
if(i < j) {
int k = j;
while(k>=i && nums[k]<0) k--;

Reverse(nums, i, k);
Reverse(nums,k+1,j);
Reverse(nums,i,j);
}
}

private void Swap(int[] nums, int i, int j)
{
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}

private void Reverse(int[] nums, int i, int j)
{
while(i < j) {
Swap(nums, i, j);
i++;
j--;
}
}

下面是自底向上的迭代版本。空间复杂度是O(1).

public void Reorder(int[] nums)
{
int n = nums.Length;

for(int size = 1; size < n; size += size)
{
for(int low = 0; low < n-size; low+=size+size)
{
Merge(nums, low, Math.Min(low+size+size-1, n-1));
}
}
}