排序算法稳定性：两个相同的元素排序前后的相对位置关系不会发生改变。
复杂度比较
| 算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(N^2) | O(N^2) | O(N^2) | O(1) | 稳定 |
| 插入排序 | O(N^2) | O(N) | O(N^2) | O(1) | 稳定 |
| 选择排序 | O(N^2) | O(N^2) | O(N^2) | O(1) | 稳定 |
| 希尔排序 | O(N ^ 3/2 ) | O(N^2) | O(1) | 不稳定 | |
| 堆排序 | O(NlogN) | O(NlogN) | O(NlogN) | O(1) | 不稳定 |
| 归并排序 | O(NlogN) | O(NlogN) | O(NlogN) | O(N) | 稳定 |
| 快速排序 | O(NlogN) | O(NlogN) | O(N^2) | O(logN) | 不稳定 |
冒泡排序
排序过程
- 将第一个元素与第二个元素比较大小，如果第一个元素大于第二个元素则调换他们两的位置；
- 比较第二个元素和第三个元素的大小，如果第二个元素大于第三个元素则调换他们两的位置；
- 依次类推，进行两两元素的比较和交换，最终最大的元素排在了最后面；
- 重复1到3过程，直到所有元素都排序。
图片演示
//冒泡排序
//平均时间复杂度:O(N^2)
//最坏情况复杂度:O(N^2)
//空间复杂度:O(1)
//稳定排序
void bubblesort(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])
swap(a[j], a[j+1]);
}
}
}
//冒泡排序升级版1
//设置一个标记来标志一趟比较是否发生交换
//如果没有发生交换，则数组已经有序
void bubblesort2(vector<int>& a)
{
int n = a.size();
bool flag;
for (int i = 0; i < n; i++)
{
flag = false;
for (int j = 0; j < n - 1 - i; j++)
{
if (a[j] > a[j+1])
{
swap(a[j], a[j+1]);
flag = true;
}
}
if (!flag)
break;
}
}//冒泡排序优化二
//用一个变量记录下最后一个发生交换的位置，后面没有发生交换的已经有序
//所以可以用这个值来作为下一次比较结束的位置
void bubblesort3(vector<int>& a)
{
int n = a.size();
int flag = n;
int stop_pos;
for (int i = 0; i < n; i++)
{
stop_pos = flag - 1;
flag = 0;
for (int j = 0; j < stop_pos; j++)
{
if (a[j] > a[j+1])
{
swap(a[j], a[j+1]);
flag = j + 1;
}
}
}
}
插入排序
- 对于第K个元素，将该元素的值存储在零时变量中，比较第前一个元素与该元素的大小，如果大于该元素就将前一个元素往后移动一步；
- 比较前面第二个元素与该元素的大小，如果大于该元素就将前第二个元素往后移动一步；
- 重复上述过程直到找到小于等于原来第K个元素（保存在零时变量中）的位置，并将第K个元素插入到这个元素的后面。或者找不到小于等于第K个元素的位置，就将原来第K个元素插入到数组的首地址。
图片演示
//插入排序
//平均时间复杂度:O(N^2)
//最坏情况复杂度:O(N^2)
//最好情况复杂度:O(N)
//空间复杂度:O(1)
//最多需要n(n−1)/2次比较
//最少需要n−1次比较
//稳定排序
void insertsort(vector<int>& a)
{
int n = a.size();
for (int i = 1; i < n; i++)
{
int insert_num = a[i], j;
for (j = i - 1; j >= 0; j--)
{
if (a[j] > insert_num)
a[j + 1] = a[j];
else
break;
}
a[j + 1] = insert_num;
}
}
选择排序
1、每一次从后面选择出一个最小的值（swap_pos），替换到前面来(i)。
//选择排序
//平均时间复杂度 O(n^2)
//最坏时间复杂度 O(n^2)
//最好时间复杂度 O(n^2)
//空间复杂度 O(1)
//我这个写法 是稳定排序
void select_sort(vector<int>& vt)
{
for (int i = 0; i < vt.size() - 1; i ++)
{
int swap_pos = i;
for (int j = i + 1; j < vt.size(); j++)
{
if (vt[swap_pos] > vt[j])
{
swap_pos = j;
}
}
if (swap_pos != i)
{
swap(vt[swap_pos], vt[i]);
}
}
}希尔排序
希尔排序是在插入排序的基础上进行发展的，通过一个希尔增量先排序一定间隔的数据。
排序过程
- 插入排序每次与前面一个比较，然后再往前一个，而希尔排序每次往前K个；
- 当增量为1的时候，希尔排序与插入排序就完全是一样的过程；
- 所以代码也很好实现，将插入排序中增1的地方改为增K就行。
图片演示
| 初始 | 81 | 94 | 11 | 96 | 12 | 35 | 17 | 95 | 28 | 58 |
|---|---|---|---|---|---|---|---|---|---|---|
| 第一趟5排序后 | 35 | 17 | 11 | 28 | 12 | 81 | 94 | 95 | 96 | 58 |
| 第二趟3排序后 | 28 | 12 | 11 | 35 | 17 | 81 | 58 | 95 | 96 | 94 |
| 第三趟1排序后 | 11 | 12 | 17 | 28 | 35 | 58 | 81 | 94 | 95 | 96 |
复杂度分析
希尔排序的时间复杂度比较复杂，选用不同的希尔增量也会导致复杂度不同。
//希尔排序
//最坏情况复杂度:O(N^2)
//不稳定排序
void shellsort(vector<int>& a)
{
int n = a.size();
for (int increment = n / 2; increment > 0; increment /= 2)
{
for (int i = increment; i < n; i++)
{
int insert_num = a[i], j;
for (j = i - increment; j >= 0; j -= increment)
{
if (a[j] > insert_num)
a[j + increment] = a[j];
else
break;
}
a[j + increment] = insert_num;
}
}
}堆排序
排序过程
- 建立最大堆，建堆的过程是从N/2的位置开始，将父节点与子节点比较，如果子节点大于父节点则交换。为什么是N/2，是因为堆中树叶的个数是N/2。
- 从堆中删除堆顶元素，对于最大堆而言，堆顶元素也就是最大元素。每删除一个堆顶元素，就将堆顶元素放在数组的后面，因为每删除一个就出现一个空位，所以数组后面是有地方存放的。
- 进行N-1次的删除以后，整个数组就是排序的状态了。
图片演示
//堆排序
//建堆的平均时间是：O(N)
//建堆的最坏情况是：O(NlogN)
//删除元素的时间是：O(logN)
//整个排序平均时间复杂度：O(N+NlogN)=O(NlogN)
//最坏情况复杂度：O(NlogN)
//不稳定排序
//建立一个大顶堆O(n),要求就是 把最大的元素 移动到堆顶 也就是a[0]
void make_heap(vector<int>& a, int size) //size的当前堆的大小，也就是数组的前size个数
{
for (int i = size - 1; i > 0; i--)
{
if (i % 2 && a[i] > a[(i - 1) / 2])//奇数
swap(a[i], a[(i - 1) / 2]);
else if (i % 2 == 0 && a[i] > a[(i - 2) / 2])//偶数
swap(a[i], a[(i - 2) / 2]);
}
}
void heapsort(vector<int>& a)
{
int n = a.size();
while (n)
{
make_heap(a, n); //每次把新的最大元素移到堆顶，也就是a[0]
n--;
swap(a[0], a[n]); //然后把当前最大移动到后面来作为排好序的元素
}
}
归并排序
排序过程
- 将数组Ｎ从中间分成两个数组N1和N2；
- 将N1和N2分别递归用归并排序来排序。
- 归并N1与N2。
图片演示
//归并排序
//平均时间复杂度：O(NlogN)
//稳定排序
vector<int> mergeHelper(vector<int> &a, int left, int right)
{
if (left == right) return vector<int> (1, a[left]);
int mid = (right - left) / 2 + left;
vector<int> l = mergeHelper(a, left, mid);
vector<int> r = mergeHelper(a, mid + 1, right);
//merge
vector<int> ret;
int ll = 0, rr = 0;
while (ll < l.size() && rr < r.size())
{
if (l[ll] <= r[rr]) ret.push_back(l[ll++]);
else ret.push_back(r[rr++]);
}
while (ll < l.size()) ret.push_back(l[ll++]);
while (rr < r.size()) ret.push_back(r[rr++]);
return ret;
}
void mergesort(vector<int>& a)
{
a = mergeHelper(a, 0, a.size() - 1);
}
快速排序
排序过程
- 选择一个枢纽元，可以选择首，尾，中三个数的中位数作为枢纽元；
- 将枢纽元的为止与数组的尾地址进行交换；
- 定义两个指针，P1指向数组首地址，P2指向数组倒数第二个位置，P1所指元素的值与枢纽元比较，如果小于枢纽元则后移一位，如果大于就停下来。P1所指元素的值与枢纽元比较，如果大于枢纽元则前移一位，如果小于就停下来；
- 交换P1和P2所指向的元素；
- 重复３和４直到P1大于P2；
- 对数组的分割过程同样采用递归的方法。
快排是必须背住的排序！
//快速排序
//平均时间复杂度：O(NlogN)
//最坏情况复杂度：O(N^2)
//不稳定排序
void quicksortHelper(vector<int>& a, int start, int end)
{
if (start >= end) return;
int l = start, r = end;
int pivot = a[(end - start) / 2 + start];
while (l <= r)
{
while (l <= r && a[r] > pivot) r--;
while (l <= r && a[l] < pivot) l++;
if (l <= r) swap(a[l++], a[r--]);
}
quicksortHelper(a, start, r);
quicksortHelper(a, l, end);
}
void quicksort(vector<int>& a)
{
quicksortHelper(a, 0, a.size() - 1);
}
//快排的最差时间复杂度为O(n²)
//通常出现在选择的轴值(pivot)不能将数组划分为两个长度相等的子数组的时候
//一个较好的办法是“三数取中”，查看当前数组的第一个、中间一个和最后一个位置的数组，取其中位数，以此来降低轴值选择得不好的可能性。
int findmiddle(int a, int b, int c)
{
if (a >= b && a <= c)
return a;
else if (b >= a && b <= c)
return b;
else
return c;
}
void quicksortHelper(vector<int>& a, int start, int end)
{
if (start >= end) return;
int l = start, r = end;
int pivot = findmiddle(a[start], a[end], a[(end - start) / 2 + start]);
while (l <= r)
{
while (l <= r && a[r] > pivot) r--;
while (l <= r && a[l] < pivot) l++;
if (l <= r) swap(a[l++], a[r--]);
}
quicksortHelper(a, start, r);
quicksortHelper(a, l, end);
}
void quicksort(vector<int>& a)
{
quicksortHelper(a, 0, a.size() - 1);
}
1004
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
