AcWing 算法基础课笔记【基础算法篇】1.快速排序与归并排序

AcWing 算法基础课笔记【基础算法篇】1.快速排序与归并排序

快速排序

思想

第一步 确定分界点 $x$

对于一个无序数组$q[n]$

1. $q_l$，即无序数组的最左边
2. $q_{(l+r)/2}$，无序数组的中间
3. $q_r$，即无序数组的最右边
4. 随机值

第二步 调整区间，使得数组$q$被$x$分为左右两边，左边小于等于$x$，右边大于等于$x$

方法一：暴力做法

1. 准备$a,b$两个数组
2. 遍历一遍$q$，把小于等于$x$的放进$a$数组，把大于$x$的放进$b$数组
3. 把$a,b$数组分别放回原数组

方法二：双指针

1. 准备$i,j$两个指针，一个指头，一个指尾
2. $i$一直往后走，直到i指的那个数大于$x$
3. $j$一直往前走，直到j指的那个数小于$x$
4. 如果$i<j$，就交换两个数
5. 一直重复步骤2、3、4，直到$i、j$相遇或错开

第三步 递归处理左右两段，原因：

1. $q$只剩两个值时，交换两数，便成了一个有序序列
2. 左右两边都排好后整个序列也就排好了（左边的最大值小于等于右边的最小值）

算法模板

以$j$为分界

void quick_sort(int q[], int l, int r){
	if(l >= r) return;

	int x = q[l + r >> 1];
	int i = l - 1, j = r + 1;
	while(i < j){
		do i++; while(q[i] < x);
		do j--; while(q[j] > x);
		if(i < j) swap(q[i], q[j]);

		quick_sort(q, l, j);
		quick_sort(q, j + 1, r);
	}
}

以$i$为分界

// 从小到大
void quick_sort(int q[], int l, int r)
{
    if(l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r + 1 >> 1];//注意是向上取整,因为向下取整可能使得x取到q[l]
    while(i < j)
    {
        do i++; while(q[i] < x);
        do j--; while(q[j] > x);
        if(i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, i - 1), quick_sort(q, i, r);//不用q[l..i],q[i+1..r]划分的道理和分析4中j的情况一样
}

// 从大到小(只改两个判断符号)
void quick_sort(int q[], int l, int r)
{
    if(l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while(i < j)
    {
        do i++; while(q[i] > x); // 这里和下面
        do j--; while(q[j] < x); // 这行的判断条件改一下
        if(i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

快速排序的边界问题

参考来源：AcWing 785. 快速排序算法的证明与边界分析

1. 以$j$作为划分时，$x$不能选$q[r]$，同理也不能选$q[l+r+1>>1]$（平均值向上取整），因为在部分情况下q[r] == q[l + r + 1 >> 1]；
2. 以$i$作为划分时，$x$不能选$q[l]$，同理也不能选$q[l+r>>1]$（平均值向下取整），因为在部分情况下q[l] == q[l + r >> 1]；
3. do i++; while(q[i] < x)和do j--; while(q[j] > x)中不能用q[i] <= x和q[j] >= x来代替
4. if(i < j) swap(q[i], q[j])中可以使用i <= j
5. da
6. j的取值范围为[l..r-1]
7. while(i < j)不能改为while(i <= j)

归并排序

思想

第一步 确定分界点 $mid$

$mid=(l+r)/2$

第二步 用$mid$递归分开左右两边，只剩一个数时，自然是有序的

第三步 二路归并，把两个有序序列合并成一个有序序列

1. 准备一个新数组$res$记录答案，再准备数组$i、j$两个指针，分别指向两个序列的开头
2. 对比$i、j$对应的值，哪一个小，就把哪一个放进$res$数组里，重复此操作
3. 待一个数组遍历完之后，哪个数组还有剩余，就把剩余的值放进$res$数组里
4. 把$res$数组的值挨个传给原数组

算法模板

$mid$ 向下取整（推荐）

void merge_quick(int q[], int l, int r){
    if(l >= r) return;
    
    int mid = l + r >> 1;
    
    merge_quick(q, l, mid);
    merge_quick(q, mid + 1, r);
    
    int k = 0, i = l, j = mid  + 1;
    while(i <= mid && j <= r){
        if(q[i] <= q[j]) temp[k++] = q[i++];
        else temp[k++] = q[j++];
    }
    while(i <= mid) temp[k++] = q[i++];
    while(j <= r) temp[k++] = q[j++];
    
    for(i = l, j = 0; i <= r; i++, j++) q[i] = temp[j];
}

$mid$ 向上取整

void merge_quick(int q[], int l, int r){
    if(l >= r) return;
    
    int mid = l + r + 1 >> 1; // 向上取整
    
    merge_quick(q, l, mid - 1); // 以mid-1为分界线
    merge_quick(q, mid, r);
    
    int k = 0, i = l, j = mid; // j从mid开始
    while(i < mid && j <= r){ // i不能取到mid
        if(q[i] <= q[j]) temp[k++] = q[i++];
        else temp[k++] = q[j++];
    }
    while(i < mid) temp[k++] = q[i++]; // i不能取到mid
    while(j <= r) temp[k++] = q[j++];
    
    for(i = l, j = 0; i <= r; i++, j++) q[i] = temp[j];
}