C++数据结构

快速排序

假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数为了方便，就让第一个数6作为基准数。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。

**3  1  2 5  4  6  9 7  10  8**

在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是k。现在就需要寻找这个k，并且以第k位为分界点，左边的数都小于等于6，右边的数都大于等于6。想一想，你有办法可以做到这点吗？

方法其实很简单：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。这里可以用两个变量i和j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边（即i=1），指向数字6。让哨兵j指向序列的最右边（即j=10），指向数字8。
首先哨兵j开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵j先出动，这一点非常重要（请自己想一想为什么）。哨兵j一步一步地向左挪动（即j–），直到找到一个小于6的数停下来。接下来哨兵i再一步一步向右挪动（即i++），直到找到一个数大于6的数停下来。最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。

现在交换哨兵i和哨兵j所指向的元素的值。交换之后的序列如下。

6  1  2  5  9 3  4  7  10  8

到此，第一次交换结束。接下来开始哨兵j继续向左挪动（再友情提醒，每次必须是哨兵j先出发）。他发现了4（比基准数6要小，满足要求）之后停了下来。哨兵i也继续向右挪动的，他发现了9（比基准数6要大，满足要求）之后停了下来。

此时再次进行交换，交换之后的序列如下。

6  1  2 5  4  3  9  7 10  8

第二次交换结束，“探测”继续。哨兵j继续向左挪动，他发现了3（比基准数6要小，满足要求）之后又停了下来。哨兵i继续向右移动，糟啦！此时哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。说明此时“探测”结束。我们将基准数6和3进行交换。交换之后的序列如下。

**3  1  2  5  4  6  9 7  10  8**

到此第一轮“探测”真正结束。此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6。回顾一下刚才的过程，其实哨兵j的使命就是要找小于基准数的数，而哨兵i的使命就是要找大于基准数的数，直到i和j碰头为止。
OK，解释完毕。现在基准数6已经归位，它正好处在序列的第6位。此时我们已经将原来的序列，以6为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“9 7 10 8”。接下来还需要分别处理这两个序列。因为6左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。现在先来处理6左边的序列现吧。

左边的序列是“3 1 2 5 4”。请将这个序列以3为基准数进行调整，使得3左边的数都小于等于3，3右边的数都大于等于3。好了开始动笔吧。

如果你模拟的没有错，调整完毕之后的序列的顺序应该是。

​ 2 1 3 5 4

OK，现在3已经归位。接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。对序列“2 1”以2为基准数进行调整，处理完毕之后的序列为“1 2”，到此2已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下。

1 2 3 4 5 6 9 7 10 8

对于序列“9 7 10 8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会得到这样的序列，如下。

1 2 3 4 5 6 7 8 9 10

到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。

后注：回到刚开始的时候提的问题，当选取最左边的数字为基准数的时候，为什么要先从右边开始搜索？ 要回答为什么先从右边开始搜索，不妨我们先从左边开始搜索。比如说“6 1 2 7 9 3 4 5 10 8”的第一轮，我们先让i从左边开始，遇到小于等于6的继续走，大于6的停下，于是i停在了7的位置；再让j从右边走，小于6的时候停下，于是j停在5的位置；这个时候i < j 于是7和5交换位置变成“6 1 2 5 9 3 4 7 10 8”；继续上面的操作，9和4交换，变成“6 1 2 5 4 3 9 7 10 8”，继续，i先走，停在了9的位置，这个时候i == j了，那么这一轮就比较完了，最后需要交换i和base位置的数（基准数归位），这个时候发生了什么？？6与9交换，变成了下面的序列：“9 1 2 5 4 3 6 7 10 8”，这个序列并不是完成了一轮处理之后，基准数左边的都比基准数小，右边的都比它大。所以这样先从左边开始搜索得不到正确结果的。

  因此，我们可以得到下面的结论：当基准数选择最左边的数字时，那么就应该先从右边开始搜索；当基准数选择最右边的数字时，那么就应该先从左边开始搜索。不论是从小到大排序还是从大到小排序！

快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。

#include <vector>
#include <iostream>
using namespace std;
//快速排序（从小到大）
void quickSortUpper(int left, int right, vector<int>& arr)
{
	if (left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		while (arr[j] >= base && i < j)
			j--;
		while (arr[i] <= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[i];
	arr[i] = base;
	quickSortUpper(left, i - 1, arr);//递归左边
	quickSortUpper(i + 1, right, arr);//递归右边
}
//快速排序（从大到小）
void quickSortLower(int left, int right, vector<int>& arr)
{
	if (left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		while (arr[j] <= base && i < j)
			j--;
		while (arr[i] >= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[i];
	arr[i] = base;
	quickSortLower(left, i - 1, arr);//递归左边
	quickSortLower(i + 1, right, arr);//递归右边
}
//快速排序（topk）
void quickSortTopK(int left, int right, vector<int>& arr,int K)
{
	if (left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		while (arr[j] <= base && i < j)
			j--;
		while (arr[i] >= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[i];
	arr[i] = base;
	if (i >= K) {
		return;
	}
	else {
		quickSortTopK(i+1, right, arr,K-i);//递归左边
	}
}



int main() {
	vector<int > arr;
	arr = { 3 , 1 , 2 ,5 , 4 , 6 , 9 , 7 , 10 , 8 };
	quickSortUpper(0, arr.size() - 1, arr);
	for (int i : arr) {
		cout << i << " ";
	}
	cout << endl;
	arr = { 3 , 1 , 2 ,5 , 4 , 6 , 9 , 7 , 10 , 8 };
	quickSortLower(0, arr.size() - 1, arr);
	for (int i : arr) {
		cout << i << " ";
	}
	cout << endl;
	arr = { 3 , 1 , 2 ,5 , 4 , 6 , 9 , 7 , 10 , 8 };
	int K = 6;
	quickSortTopK(0, arr.size() - 1, arr,K);
	int i = 0;
	while (i < K) { cout << arr[i] << " "; i++; }


}

在大规模数据处理中，经常会遇到TopK问题，也就是在海量数据中找到最大/小的k个数。这也是校招面试常问的算法题，TopK问题的应用场景很多，比如微博中找到搜索关键字中最热的10个词作为热搜、搜索引擎中找到一段时间中搜索次数最多的k个关键字，歌曲库中统计下载次数最多的k首歌曲等等。

top K问题

1.傻瓜排序

排序是最容易想到的方法，将n个数排序之后，取出***的k个，即为所得。其时间复杂度是O(nlogn)，但是问题来了，如果前提是以亿为单位的数据，你还敢用排序算法吗？明明只需要k个数，为啥要对所有数都排序呢？并且对这种海量数据，计算机内存不一定能扛得住。

#include <algrithm>

vector<int>arr;
...
sort(arr);

2.局部排序(冒泡)

既然只需要k个数，那么我们可以再优化一下，先用一个容器装这个数组的前k个数，然后找到这个容器中最小的那个数，再依次遍历后面的数，如果后面的数比这个最小的数要大，那么两者交换。一直到剩余的所有数都比这个容器中的数要小，那么这个容器中的数就是最大的k个数。
这种算法的时间复杂度为O(n*m)，其中m为容器的长度。
具体地，其过程如下图所示：

那么这种方法的时间复杂度也太大，同样的思路，我们其实还可以利用最大/小堆来实现，这就引出了下一个实现方法。

3.堆（优先队列，priority_queue）

我们可以先用前k个元素生成一个小顶堆，这个小顶堆用于存储当前k个元素，例子同上，可以构造小顶堆如下：

然后从第k+1个元素开始扫描，和堆顶元素比较（最小值），如果当前元素大于堆顶元素，则替换堆顶值，并调整堆，以保证堆内k个元素一直是当前最大的k个元素，如图所示：


最终堆中的k个元素，就求的TopK。
这种堆解法的时间复杂度为O(N*logk)，并且堆解法也是求解TopK问题的经典解法，用代码实现如下：
C++优先队列详细讲解

vector<int>arr; //取其top k个元素
priority_queue<int,vector<int>,less> array;//小顶堆
for(int i=0;i<K;i++){
    array.push_back(arr[i]);
}
for(int i = K;i<arr.size();i++){
	if(array.front() < arr[i]){
		array.pop_front();
		array.push_front(arr[i]);
	}
}

4.快速排序

我们知道，快排的思想就是分治法，即分而治之，简而言之，就是把一个大问题分解为若干个子问题，然后把每个子问题都求解出来，最后整个大问题就解决了，其伪代码如下：

 void quick_sort(int  arr[], int low, int high){ 
     if(low== high) return; 
     int i = partition(arr, low, high); 
     quick_sort(arr, low, i-1); 
     quick_sort(arr, i+1, high); 
} 

那么其中的核心就在于partition(arr, low, high)上，这个partition是什么意思呢？顾名思义，就是通过这个方法把数组分为两部分。更具体地，就是以数组arr中的一个元素（一般默认是第一个元素t=arr[low]）作为划分依据，将数组arr[low,high]分为左右两个子数组：
左半部分，都比t大
右半部分，都比t小
如下图所示：

那么partition的返回结果就是t最终的位置i。
那么快排跟Topk问题有什么关系呢？回到问题本身，TopK就是希望求出数组arr[1,n]中最大的k个数，那么如果找到了第k大的数，做一次partition，不就一次性找到最大的k个数了么？结果也就是partition的右半区间的数。

那么问题最终就变成了找数组中第k大的数，回过头来看看第一次partition划分之后：

int i = partition(arr,1,n);

那么这时候有两种情况：

i > k，那么说明arr[i]左边的元素都大于k，于是只需要随后递归arr[1,i-1]里面第k大的元素即可；
i < k，那么说明第k大的元素在右边，于是只需要递归arr[i+1,n]里第k-i大的元素即可。

使用代码实现上述算法可以如下：

int findKthElement(int nums[], int k) {
    k = nums.length - k;
    int l = 0, h = nums.length - 1;
    while (l < h) {
        int j = partition(nums, l, h);
        if (j == k) {
            break;
        } else if (j < k) {
            l = j + 1;
        } else {
            h = j - 1;
        }
    }
    return nums[k];
}

int partition(int a[], int l, int h) {
    int i = l, j = h + 1;
    while (true) {
        while (a[++i] < a[l] && i < h) ;
        while (a[--j] > a[l] && j > l) ;
        if (i >= j) {
            break;
        }
        swap(a, i, j);
    }
    swap(a, l, j);
    return j;
}

void swap(int a[], int i, int j) {
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

TopK的其它问题

海量数据
海量数据前提下，肯定不可能放在单机上。

拆分，可以按照哈希取模或者其它方法拆分到多台机器上，并在每个机器上维护最小堆
整合，将每台机器上得到的最小堆合并成最终的最小堆
频率统计
找出一个数据流中最频繁出现的k个数，比如热门搜索词汇等。

动态规划