算法——选择与排序

leetcode75颜色分类——堆排序

采用最小堆进行处理

func sortColors(nums []int)  {
    n := len(nums)
    b := n-1
    for i:=0; i <= b; i++{
        MinHeap(nums, i, b)
    }
}

func MinHeap(nums []int, a int, b int){//将nums数组中从a到b的元素看作一个最小堆，进行处理
    n := b - a + 1
    for i := a + n/2 - 1; i >= a; i--{
        HeapAdjust(nums, a, b, i)
    }
}

func HeapAdjust(nums []int, a int, b int, i int){//将最小堆中的第i个数的位置进行调整
    wn := nums[i] //需要调整的数据
    max := i
    j := 2*i-a+1
    for j <= b{
        if j < b && nums[j+1] < nums[j] {
            j += 1
        }
        if nums[i] < nums[j] {
            break
        }
        max = j
        nums[i] = nums[max]
        i = max
        j = 2*i-a+1
    }
    nums[max] = wn
}

洛谷1090合并果子——堆的实战利用

• 注意重整函数的参数中的长度m非常重要，给该函数传递长度不仅可以避免使用vector，同时也可以方便后续继续修改堆的长度。

AC代码

#include<iostream>
using namespace std;
int n, x1, sum, ans;
int hp[10005];
// 表示对长度为m的堆中的第s个进行重整
void HeapAdjust(int s, int m) { 
    int tmp = hp[s];
    for(int j = s*2; j <= m; j*=2) {
        if(j < m && hp[j] > hp[j+1]) ++j;
        if(tmp <= hp[j]) break;
        hp[s] = hp[j]; s = j;
    }
    hp[s] = tmp;
}

int main() {
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> hp[i];
    //维护出小顶堆
    for(int i = n/2; i > 0; i--) HeapAdjust(i, n);
    for(int i = 1; i <= n-1; i++) {
        x1 = hp[1]; // 取出第一个最小值
        hp[1] = hp[n-i+1];
        HeapAdjust(1, n-i);
        sum = x1 + hp[1]; // 每合并一次的总和
        hp[1] = sum;
        HeapAdjust(1, n-i);
        ans += sum;
    }
    cout << ans;
    return 0;
}

洛谷P1138第k小整数

求解一串数的第k小的数

1）方法：
主席树（可持续化线段树）（还没有学习orz）
快速排序之后再去重即可

2）辨析

• 主席树：求解第k小的数（具体可以干啥，后面学习之后再补充）
• 堆排序：使用于关键字较多的情况，例如，在一亿个数中选出前100个最大值？先建立一个大小为100的最小堆，然后一次读入余下的数，若小于堆顶则舍弃，否则用该数取代堆顶并重新调整堆，待数据读取完毕，堆中100个数即为所求。

洛谷P1918保龄球——哈希表

1）技巧：对于数组内容和下标互相关联，而且需要对其进行排序时，可以考虑使用c++内置的map。map 提供键值对来解决此类问题

//p1918保龄球
#include<iostream>
#include<map>
using namespace std;
map<int, int> a;
int main(){
    int n, x, m, Q;
    scanf("%d",&n);
    for(int i = 1; i <= n; i++){ scanf("%d", x); a[x] = i}
    scanf("%d",&Q);
    for(int i = 1; i <= Q; i++){
        scanf("%d", &m);
        printf("%d\n", a[m]);
    }
    return 0;
}

2）常规解法：结构体快速排序（键值对一起排序）+ 二分查找

• 二分查找算法实现

//binary_search

洛谷P1309瑞士轮——深入理解归并排序

• 归并排序有两种方式，递归形式的以及迭代形式的

第一种：递归形式的归并排序

最原始的基于递归的归并排序：

（这种归并排序算法一般不怎么使用，因为实用性比较低）

void Merge(int array[], int l, int mid, int r) {
    //要归并[l, mid] 以及 [mid+1, r] 两部分的数字
    int *temp = new int[r-l+1];//临时数组
    int i, j ,k = 0;
    for(i = l, j = mid+1; i <= mid && j <= r; ) {
        if(array[i] < array[j]) temp[k++] = array[i++];
        else temp[k++] = array[j++];
    }
    while(i <= mid) temp[k++] = array[i++];
    while(j <= r) temp[k++] = array[j++];
    memcpy(array+l, temp, (r-l+1)*sizeof(int));//拷贝到array中
    delete[] temp;
}
void MergeSort(int array[], int l, int r) {//按照升序排序
    if(l >= r) return;
    int mid = (l+r)/2;
    MergeSort(array, l, mid);
    MergeSort(array, mid+1, r);
    Merge(array, l, mid, r);
}

• 这种基本的归并排序时间和空间复杂度都比较稳定，但是也有很多地方可以改良。下面讨论两种比较常见的优化方案

1. 在处理规模比较小的数组排序时，往往插入排序比归并排序要快，所以可以在归并排序递归的小规模子问题上直接转用插入排序。只需要在递归函数的结束条件处稍加改良即可。

	//原来
	if(l >= r) return;
	//改进后
	if(r - l <= 10) {
		InsertSort(array, l , r);
		return;
	}

改进后的递归结束条件不仅可以在适当的时候结束递归，还可以在子问题规模较小的时候将排序转交给插入排序处理。

2. 在归并时检查，如果两个子数组本身就可以直接合并，并且还不会影响其有序性，那么也就不用花时间去合并了。

void Merge(int array[], int l, int mid, int r) {
	//此处加上一行判断条件，如果有序，直接退出，不用花时间归并！
	if(array[mid] <= array[mid+1]) return;
    //要归并[l, mid] 以及 [mid+1, r] 两部分的数字
    int *temp = new int[r-l+1];//临时数组
    int i, j ,k = 0;
    for(i = l, j = mid+1; i <= mid && j <= r; ) {
        if(array[i] < array[j]) temp[k++] = array[i++];
        else temp[k++] = array[j++];
    }
    while(i <= mid) temp[k++] = array[i++];
    while(j <= r) temp[k++] = array[j++];
    memcpy(array+l, temp, (r-l+1)*sizeof(int));//拷贝到array中
    delete[] temp;
}

第二种：基于迭代形式的归并排序

基于迭代的二路归并排序思想。将数组中元素两两归并，然后再进行两个子数组两两归并，一直进行到得到一个长度为N的原数组即可。

void MergeSort(int array[]) {//按照升序排序
    int N = array.size();
    for(int size = 1; size < N; size *= 2) {
    //让low+size小于N，确保最后一次的归并有两个区间
        for(int low = 0; low+size < N; low += 2*size) {
            int mid = low+size-1;
            int high = low + 2*size - 1;
            if(high > N-1) high = N-1;
            //合并的函数并没有改变，只是需要重新得到新的mid和high
            Merge(array, low, mid, high);
        }
    }
}