划分方法的应用

划分对于分治的算法设计很重要，下面就专门说一个划分的算法设计，然后再举例子说一些具体的应用。

int Partition(int data[], int start, int end)
{
if(data == NULL)
return -1;
int index = RandomInRange(start, end);
int small = start - 1;

swap(data[index], data[end]);

for(index = start; index < end; index++)
{
if(data[index] < data[end])
{
++small;
if(small != index)
{
swap(data[small], data[index]);
}//if
}//if
}//for

++small;
swap(data[small], data[end]);

return small;
}//Partition()

　　下面看一下划分的应用。

快速排序中的划分

void QuickSort(int data[], int start, int end)
{
if(start == end)
return;

int index = Partition(data, start, end);

if(index > start)
QuickSort(data, start, index - 1);
if(index < end)
QuickSort(data, index + 1, end);
}

　　递归的程序一定要有递归出口。

查找第K大的数字

int findKth(int *data, int start, int end, int k)
{
int pos = partition(data, start, end);
if(pos + 1 == k)
return data[pos];
else if(pos + 1 > k)
return findKth(data,start, pos -1, k);
else
return findKth(data, pos + 1, end, k);
}

int findKthLargest(int *nums, int numsSize, int k)
{
//转换成求第k小元素
　　　int m = numsSize - k +  1;

　　　int result = findKth(nums, 0, numsSize - 1, m);

　　　return result;
}

　　

数组中出现次数超过一半的数字

这个问题貌似很难，但是设想如果这个数组已经排序好了，那么这个出现次数超过一半的数字肯定会出现在中位数的地方。所以可以利用上面的算法，找数组中的中位数小的元素。

但是测试用例一定要首先写好，要防止空的数组、数组中根本不存在超过一半多这样的数字，这次用循环来实现找第k小的元素，不用递归了。

int MoreThanHalfNum_Solution(vector<int> numbers)
{
if(numbers.size() == 0)
return 0;

int start = 0;
int end = numbers.size() - 1;
int middle = numbers.size() >> 1;

int index = partition(numbers, start, end);

while(index != middle)
{
if(index > middle)
{
end = index - 1;
index = partition(numbers, start, end);
}
else
{
start = index + 1;
index = partition(numbers, start, end);
}
}//while

int result = numbers[middle];

if(!checkMoreThanHalf(numbers,result))
{
return 0;
}

return result;
}

　　注意上面的循环的方式，感觉比递归的方式更好。但是通过中位数找到的数字可能不是正确的答案，最后要验证一下，这个数字是不是出现的次数多于数组大小的一半。

bool checkMoreThanHalf(vector<int> &numbers, int result)
{
int times = 0;
for(int i = 0; i < numbers.size(); i++)
{
if(numbers[i] == result)
{
times++;
}
}//for

if(times * 2 > numbers.size())
{
return true;
}

return false;
}

　　注意上面的函数的返回值：正确的情况下，返回查找到的数据，错误的时候，返回错误码0。

不管怎么弄，上面的算法的实现都是基于划分算法来实现的，其实除了这种方法，还可以有其他的解决方案：

设置两个变量，一个变量用于保存目前出现次数最多的那个数字，另一变量用来记录出现的次数。随着不断的遍历，每遍历一个数，如果和前面保存的数字相同，计数器就+1，不相同就-1。如果计数器减到0，就代表之前存的数已经被淹没掉了，这是要重新记录新的数字，同时置计数变量为1。既然结果数字多于数组个数的一半，那么最后记录中留下的肯定是这个结果数字。但是要注意，原数组中可能本来就没有多于一半的这样的数字，但是最后还是会有一个结果的，所以要最后校验一次。如果发现错误的话，及时的返回错误码0。

int MoreThanHalfNum(vector<int> numbers)
{
int times = 1;
int result = numbers[0];

for(int i = 1; i < numbers.size(); i++)
{
if(numbers[i] == result)
{
times++;
}
else
{
times--;
if(times == 0)
{
result = numbers[i];
times = 1;
}

}//else
}//for

if(!checkMoreThanHalf(numbers, result))
{
return 0;
}

return result;
}

　　对于查找数组中出现次数多于一半的数字，有这两种方法，他们的时间复杂度都是O(n)，但是注意第一种改变了原来的数组，但是第二种没有改变原数组，是一种很好的方法。

获取数组中的最小的K个数

这个题目第一次看到可能会想到先排序，然后就可以很简单的获得最小的k个数了，但是排序的时间复杂度是O(nlogn)，这可能达不到算法时间复杂度的要求，所以又想到了划分。类似前面那个出现次数大于数组个数一半的题目，只要划分能够定位到k-1那个元素。那么[0...k-1]的这些数字就是最小的k个数字。

vector<int> GetKLeastNumbers(vector<int> input, int k)
{
vector<int> result;

if(input.size() == 0 || k <= 0 || k > input.size())
return result;

int start = 0;
int end = input.size() - 1;

int index = partition(input, start, end);
while(index != k - 1)
{
if(index > k -1)
{
end = index - 1;
index = partition(input, start, end);
}
else
{
start = index + 1;
index = partition(input, start, end);
}

}//while

for(int i = 0; i < k; i++)
{
result.push_back(input[i]);
}

return result;
}

　　但是这个算法会改变原来的数组，所以如果要求不改变原来的数组，得想另外的办法。

最小K个数的另一种解决的办法

我们可以另外建立一个容器，在这个容器中存储最小的K个数字。一次遍历原始的数字，如果这时K的容器数组没有满，直接把这个原始数据放到容器中，如果容器已经满了，则比较原始数组的值和容器中最大值，如果原始的数字小，则替换容器中的最大值。否则忽略这个原始的数据，继续向后遍历。

因此在容器满了之后要做下面3件事：

在K的容器中，找到最大值；可能会删除这个最大值；可能会插入一个新的值。

如果用一个二叉树完成上面的3个操作，时间复杂度就能够控制在O(logk)，这样的话整个算法的时间复杂度控制在O(nlogk)。由于每次都是从容器中找到最大值，所以很容易考虑到最大堆，这样的话就可以在O(1)的时间找到容器的最大值，但是删除和插入的时间复杂度是O(logk)。

对于二叉树，可以选用set或者multiset来代替，因为这两个东西都是基于红黑树实现的，红黑树的查找、删除、插入的时间复杂度都是O(logk)。

typedef multiset<int, greater<int> > intSet;
typedef multiset<int, greater<int> >::iterator setIterator;

vector<int> GetKLeastNumbers(const vector<int> &data, int k)
{
intSet leastNumbers;
vector<int> result;

int len = data.size();

leastNumbers.clear();

//检验边界值，增加代码的健壮性
if(k < 1 || data.size() == 0 || data.size() < k)
{
return result;
}

for(int i = 0; i < len;i++)
{
if(leastNumbers.size() < k)
{
leastNumbers.insert(data[i]);
}
else
{
setIterator iterGreatest = leastNumbers.begin();

if(data[i] < *(leastNumbers.begin()))
{
leastNumbers.erase(iterGreatest);
leastNumbers.insert(data[i]);
}
}//else
}//for

//放到vector中返回数据
for(setIterator iterK = leastNumbers.begin(); iterK != leastNumbers.end(); iterK++)
{
result.push_back(*iterK);
}

return result;

}

　　这种算法的优点是它不会改动原来的数组，同时特别的适合海量的数据，因为可以不用一次把全部的数读取到内存中来，可以分批的读入内存。所以这种算法很适合n很大但是k很小的情况。