排序算法

---

---

目录

1. $O\left(N^2\right)$

- 选择排序

- 冒泡排序

2. $O\left(N\log N\right)$（重点）

- 归并排序

- 快速排序

- 堆排序

3.$O\left(N\right)$(重点)

- 桶排

---

---

一、 $O\left(N^2\right)$

$\left(1\right)$选择排序（不稳定）

1.原理：判断这个数以后的所有数，将小的放在前面，如果没有，就swap（挖坑）

2.考点：复赛基本不用，初赛要考

3.关键代码：

for(int i=1;i<=N;i++)
{
   
	for(int j=i+1;j<=N;j++)
	{
   
		if(a[i]>a[j])
		{
   
			swap(a[i],a[j]);
		}		
	}	
} 

4.时间复杂度：

最好情况： $O\left(N\right)$

最坏情况： $O\left(N^2\right)$

平均情况： $O\left(N^2\right)$

---

$\left(2\right)$ 冒泡排序（不稳定）

1.原理：比较相邻的元素，将小的放在前面

2.考点：初赛重点

3.关键代码：(初始代码)

for(int i=1;i<=N;i++)
{
   
	for(int j=1;j<=N-i;j++)
	{
   
		if(a[j]>a[j+1])
		{
   
			swap(a[j],a[j+1]);
		}
	}
}

还可以优化一下,当发现没有交换，就跳出循环

bool flag = true;
int k = n;
while(flag)
{
   
    flag = false;
    for(int i=1;i<=k;i++)
    {
   
        if(a[i]>a[i+1])
        {
   
            swap(a[i],a[i+1]);
            flag = true;
        }
    }
    k--;
}

4.时间复杂度

最好情况： $O\left(N\right)$

最坏情况： $O\left(N^2\right)$

平均情况： $O\left(N^2\right)$

---

---

二、 $O\left(N\log N\right)$

$\left(1\right)$快速排序（不稳定）

1.原理：冒泡排序的改进，用二分的思想进行优化

2.考点：几乎所有时候，快排都能过（除了卡快排的题 如P1309 瑞士轮||数据太大的题）

3.优化：三平均分区法

（以下摘自百度）

关于这一改进的最简单的描述大概是这样的：与一般的快速排序方法不同，它并不是选择待排数组的第一个数作为中轴，而是选用待排数组最左边、最右边和最中间的三个元素的中间值作为中轴。这一改进对于原来的快速排序算法来说，主要有两点优势：

①首先，它使得最坏情况发生的几率减小了。

②其次，未改进的快速排序算法为了防止比较时数组越界，在最后要设置一个哨点。

4.关键代码：

①STL自带函数

sort(a+1,a+n+1); //a为数组名（默认从小到大）

可以配合cmp函数使用

bool cmp(int x,int y){
   return x>y;}//（从大到小cmp）

结构体排序可以使用cmp函数，也可使用重载运算符

cmp

struct node
{
   
	int id,v;	
};
bool cmp(node x,node y)
{
   
	if(x.v>y.v) return 1;
	else if(x.id<y.id) return 1;
	return 0;
}

重载运算符

struct node
{
   
	int id,v;
	bool operator <(const node &n)const
	{
   
		if(v>n.v) return 1;
		else if(id<n.id) return 1;
		return 0;		
	}	
};

②自己写二分（不推荐，既然有了STL，还要什么二分）

（以下摘自Hardict大佬）

void swap(int arr[], int i, int j)
{
   
    int temp;

    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
void QuickSort(int arr[], int left, int right)
{
   
    int i, pivot;

    if (left >= right)
        return;
    pivot = left;
    swap(arr, left, (left + right) / 2);
    for (i = left + 1; i <= right; i++) //单边搜索，可以该为双向搜索（据说快点( ° ▽、° )）
        if (arr[i] < arr[left])
            swap(arr, i, ++pivot);
    s