快速排序、归并排序、二分查找

目录

一、快速排序

二、归并排序

三、逆序对数量

四、二分查找

1.整数二分

整数二分习题

2.浮点数二分

总结

---

一、快速排序

  主要思想：确定一个枢轴，把数组中大于枢轴的放在右边，小于枢轴的放在左边，然后递归排序左右两端，当排序区间足够小时，这样做就可以排序好整个数组。

1.确定返回条件   2.双指针，找出左右两端不符合条件的点，然后交换（注意i<j时才需要交换）

3.递归排序左右两端。

void quicksort(int* num, int l, int r)
{
	if (r <= l) return;
	int x = l, y = r, z = num[l];//选取了num[l]为枢轴，所以第一个元素不会丢失。
	while (x < y) {
		while (x < y && num[y] >= z) --y;
		if (x < y) num[x++] = num[y];
		while (x < y && num[x] <= z) ++x;
		if (x < y) num[y--] = num[x];
	}
	num[x] = z;
	quicksort(num, l, x - 1);
	quicksort(num, x + 1, r);
}
//优化过的快排  优化：枢轴的选择
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];  //注意是l-1 和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]);//注意这里if的条件判断
	}

	quick_sort(q, l, j);//必须上界是j j+1;或者是i-1 i; 注意若选取i-1为上界 枢轴不可为q[l]，右侧递归会死循环; 选取j为上界同理
	quick_sort(q, j + 1, r);
}

二、归并排序

1.确定返回条件 2.确定分界点 3.递归排序左右两端   4. 合并数组，因为已经排序完了，所以用双指针合并就好了。5.扫尾 6.将数值传递给原数组。

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

三、逆序对数量

题目描述如图

分析：运用归并排序的思想，假设我们的归并排序可以返回归并数组内所有的逆序对数量。

  那么对于一个数组，我们将其分为左右两端，其中的逆序对数量即位左边数组的逆序对数量加上右边数组的逆序对数量再加上左右数组互相的逆序对数量。 

  也就是说逆序对数量res=merge_sort(左边数组）+merge_sort(右边数组)+ 左右数组互相的逆序对数量。即再函数体内  res+=互相的逆序对数量。

  而在归并的过程中，我们就可以找到这个互相的逆序对数量。因为两个归并数组时升序排列的，当我们发现q[i]>q[j]时，q[i]之后的所有值都大于q[j]，与q[j]构成一个逆序对，这个数量易知为mid-i+1。

#include<iostream>
using namespace std;
const int N=100010;
int q[N],tmp[N];
long long  merge_sort(int q[],int l,int r)
{
    if(l>=r) return 0;
    int mid=l+r>>1;
    long long res=merge_sort(q,l,mid)+merge_sort(q,mid+1,r);
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j]) tmp[k++]=q[i++];
        else
        {
            tmp[k++]=q[j++];
            res+=mid-i+1;
        }
    }
    while(i<=mid) tmp[k++]=q[i++];
    while(j<=r) tmp[k++]=q[j++];
    for(i=l,j=0;i<=r;i++,j++) q[i]=tmp[j];
    return res;
    
}

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++) cin>>q[i];
    cout<<merge_sort(q,0,n-1);
}

---

四、二分查找

1.整数二分

思想：设要找的元素为x，待查找区间左右端点为l，r。我们可以设一个mid=l+r>>1，然后检查mid是否符合某种性质，若符合，则x必在mid左边，我们则令r=mid，然后循环查找，否则让l=mid+1，如此循环查找，直到l=r。

  因此需注意，如此循环是必然会找到一个“l”的，是必定有一个返回值的，因此即使x不在待查找区间中，也会返回一个值。

  回到分区间的步骤，由于check（mid）随便你怎么写，不一定满足条件x在mid左边，也可以在右边，那么我们就要令l=mid，不满足时r=mid-1。那么需要注意的是，出现mid-1时，mid的选取不可以是l+r>>1，而必须是l+r+1>>1。否则会出现死循环。eg：区间长度为2时。

两种二分代码如下：

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

作者：yxc
链接：https://www.acwing.com/blog/content/277/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

整数二分习题

第一种方式可以找出l，第二种方式找出r，具体实现自己想想，，

#include<iostream>
using namespace std;
const int N =100005;
int q[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)  cin>>q[i];
    while(m--)
    {
        int x;
        cin>>x;
        int l=0,r=n-1;
        while(l<r)
        {
            int mid=l+r>>1;
            if(q[mid]>=x) r=mid;
            else l=mid+1;
        }
        if(q[l]!=x) cout<<"-1 -1"<<endl;
        else
        {
            cout<<l<<" ";
            l=0;r=n-1;
            while(l<r)
            {
                int mid=l+r+1>>1;
                if(q[mid]<=x) l=mid;
                else r=mid-1;
            }
            cout<<l<<endl;
        }
        
    }
    return 0;
}

2.浮点数二分

  判断条件可以是r-l小于一个很小的值，这个值决定了精度。l，r的变化直接取mid就完了，没那么多要求。

如题，找出一个数的三次方根。

bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    re

总结

 记录了快速排序，归并排序，二分查找的代码模板以及简单应用。