好吧，我现在没有网，我现在就只能做一下这些线下的工作
那我准备在下午完成排序算法和STL的整理
数据结构也基本上就只差排序和那个字符串的KMP算法了
1 排序算法
排序算法的稳定性：
如果元素中有两个元素k1, k2，排序之前k1排在k2前面，排序之后k1也是排在k2前面，则称排序是稳定的
内排序和外排序
内排序就是说排序过程中数据都在内存里，不用来回交换；外排序就是数据在内存一部分在外存一部分啦
性能评估
数据比较次数和数据移动次数
靠 我刚写了几行字就有网了，好吧，那也得等我写完这一篇吧
2 插入排序
2.1 直接插入排序
核心思想：插入第i个元素时，前面i - 1个元素都已经排好序了
```C++
void insert_sort(vector<int>& v)
{
int n = v.size();
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
if(v[i] < v[j])
{
int k = i;
int tmp = v[i];
while(k > j)
{
v[k] = v[k - 1];
k--;
}
v[j] = tmp;
break;
}
}
}
}
```
时间复杂度O(n^2)
2.2 二分排序
在插入第i个元素时，前i - 1个元素都已经排好序， 利用折半查找的思路查找v[i]的插入位置
也就是将直接插入排序的查找比较过程变成了折半查找
```C++
void binary_insert_sort(vector<int>& v)
{
int n = v.size();
for(int i = 1; i < n; i++)
{
int left = 0;
int right = i - 1;
int mid = (left + right) / 2;
int tmp = v[i];
while(left <= right)
{
mid = (left + right) / 2;
if(tmp < v[mid])
right = mid - 1;
else if(tmp > v[mid])
left = mid + 1;
else
{
left = mid + 1;
break;
}
}
for(int j = i - 1; j >= left; j--)
v[j + 1] = v[j];
v[left] = tmp;
}
}
```
折半插入排序也是稳定的
时间复杂度为O(n * logn)
2.3 希尔排序
核心思想：交换不相邻元素以对数组进行局部排序，再使用插入排序使局部有序的数组有序（gap = 1)
使用一个gap作为间隔，用插入排序是得每个间隔i, i + gap, i + 2 * gap有序
随着gap减少到1，就可以变成整个数组插入排序（但是很多已经局部有序）
为什么选择插入排序呢？因为基本上已经局部有序了，插入排序在最好情况下为O(n)，且数量较少时较为有效
```C++
void shell_sort(vector<int>& v)
{
int n = v.size();
int gap = n - 1;
do
{
gap = gap / 3 + 1;
for(int i = gap; i < n; i++)
{
for(int j = i; j >= gap; j -= gap)
{
if(v[j] < v[j - gap])
{
int tmp = v[j - gap];
v[j - gap] = v[j];
v[j] = tmp;
}
}
}
}while(gap > 1);
}
```
举个例子就理解了:
无法证明，但对任意数组表现也不错，小于O(n^2)，不稳定排序
3 交换排序
3.1 冒泡排序
非常简单的一种时间复杂度为O(n^2)的排序算法
核心思想就是：第一层循环表示多少趟， 第二层循环表示从哪到哪两两交换，如果前面比后面大，就交换（也就是把大的换到后面）
```C++
void bubble_sort(vector<int>& a)
{
int n = a.size();
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n - 1 - i; j++)
{
if(a[j] > a[j + 1])
{
int tmp = a[j + 1];
a[j + 1] = a[j];
a[j] = tmp;
}
}
}
}
```
也是稳定的
```C++
void bubble_sort(vector<int>& a)
{
int n = a.size();
for(int i = 0; i < n; i++)
{
int flag = false;
for(int j = 0; j < n - 1 - i; j++)
{
if(a[j] > a[j + 1])
{
int tmp = a[j + 1];
a[j + 1] = a[j];
a[j] = tmp;
flag = true;
}
}
if(!flag)return;
}
}
```
改进就是设置一个标志，如果这一遍冒泡没有交换任何元素，说明已经有序了，那就直接返回就好了
3.2 快速排序
典型的分治法, 选一个基准点(随便选), 通过移动使得基准点左边都是比他小的,右边都是比他大的,然后分别进入两边再排序.
对于移动元素, 快速排序是冒泡排序的改进, 不是通过不断比较交换的(相邻交换), 是直接将两个交换(跳跃交换), 但是我们又不需要把基准点赋值,最后赋值即可.
```C++
int partition(vector<int>& v, int low, int high)
{
int key = v[low];//基准点选最左边
while(low < high)
{
while(low < high && v[high] >= key) high--; //从右边开始, 右边大于key的就过掉
if(v[high] < key) //如果有小于key的就和左边未检查的部分交换,但是其实我们不需要真的把左边的赋值过来,后面会处理的
{
v[low] = v[high];
low++;
}
while(low < high && v[low] <= key) low++;//同样,再过掉左边比key小的
if(v[low] > key)//找到一个大的,就交换到右边未处理的那
{
v[high] = v[low];
high--;
}
}
v[low] = key;//结束的时候low==high,就是key应该在的位置
return low;
}
//另一个更好理解的版本
int partition(vector<int>& v, int low, int high)
{
int keypos = low;
int key = v[low];
for(int i = low + 1; i < high; i++)
{
if(v[i] < key)
{
keypos++;//keypos已左都是小于key的,如果小于key,我们就把v[i]放在keypos上,把原来那些大于未处理的交换到后面去
if(keypos != i)
{
int tmp = v[i];
v[i] = v[keypos];
v[keypos] = tmp;
}
}
}
v[low] = v[keypos];
v[keypos] = key;
return keypos;
}
void quick_sort(vector<int>& v, int low, int high)
{
if(low < high)
{
int k = partition(v, low, high);
quick_sort(v, low, k - 1);
quick_sort(v, k + 1, high);
}
}
```
快速排序也是不稳定的, 时间复杂度为O(nlogn), 是性能最好的一种内排序方法
时间复杂度取决于递归树的高度,最好情况是完全二叉树,最坏情况是单链树
快速排序的运行时间取决于输入序列, 对n较大的平均情况下, 快速排序效果较好, 对于n较小的情况下, 快排效果比简单排序效果差
快速排序的改进
我们上面说到如果规模很小时,使用直接插入排序是一个很好的办法,所有我们可以设置在high - low < M时选择直接插入排序;或者说我们小于一定规模就返回,这样最终得到的是一个基本上已经排好序的数组,我们再最后调用一遍直接插入排序就好了
还有基准元素的选择也对快速排序有影响,我们最希望的是左右平分, 基准元素位于中间,因此我们可以随机选择基准元素.
4 选择排序
4.1 简单选择排序
核心思想:选出未排序中最小的不断放在未排序的后面
```C++
void select_sort(vector<int>& v)
{
for(int i = 0; i < v.size() - 1; i++)
{
int pos = i;
for(int j = i + 1; j < v.size(); j++)
{
if(v[j] < v[pos])
pos = j;
}
int tmp = v[pos];
v[pos] = v[i];
v[i] = tmp;
}
}
```
不稳定排序算法, 时间复杂度也是O(n^2)
4.2 堆排序
见堆
5 归并排序
归并排序和快速排序类似, 也是基于分治法的, 将序列分成两个长度相等的子序列,对子序列进行排序,然后再将其合并.
归并排序不依赖输入序列, 避免了快排的最坏情况
所以, 归并排序主要包括两步: 划分 合并(合并两个有序表)
```C++
void merge(vector<int>& v, vector<int>& s, int left, int mid, int right)
{
for(int i = 0; i < v.size(); i++)
s[i] = v[i];
int p1 = left, p2 = mid + 1, p = left;
while(p1 <= mid && p2 <= right)
{
if(s[p1] < s[p2])
v[p++] =s[p1++];
else
v[p++] = s[p2++];
}
while(p1 <= mid)
v[p++] = s[p1++];
while(p2 <= right)
v[p++] = s[p2++];
}
void merge_sort(vector<int>& v, vector<int>& s, int left, int right)
{
if(left >= right) return;
int mid = (left + right) / 2;
merge_sort(v, s, left, mid);
merge_sort(v, s, mid + 1, right);
merge(v, s, left, mid, right);
}
```
归并排序是一种稳定排序方法, 时间复杂度为O(nlogn), 空间复杂度需要一个O(n)的辅助数组
6 总结
- 简单排序方法主要包括直接插入排序、冒泡排序、选择排序， 他们适合数量较小的序列，时间复杂度是O(n^2)， 空间复杂度忽略不计
直接插入排序最好情况下能够只比较n - 1次，不用移动
改进的冒泡排序最好情况下， 也只比较n - 1次即可
选择排序比较次数与初始序列无关，都需要比较n^2次， 但是元素移动与初始有关
- 快速排序、归并排序、堆排序都是比较高效的排序方法， 时间复杂度都在O(nlogn)
快排就是与选择的基准元素有关，归并排序就与初始序列无关
-
希尔排序介于简单排序和高效排序之间
-
稳定的算法有：冒泡、直接插入、折半插入、归并
663
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
