本文详细介绍了四种常见的排序算法：插入排序（直接插入和希尔排序）、选择排序（简单选择和堆排序）、交换排序（冒泡排序和快速排序）以及归并排序。针对每种排序算法，文章提供了详细的原理分析和步骤说明，帮助读者理解它们的工作机制。
1.排序的概念
排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2.算法分析
- 插入排序
- 直接插入排序
将第一个和第二个元素排好序，然后将第3个元素插入到已经排好序的元素中，依次类推（插入排序最好的情况就是数组已经有序了）
- 希尔排序
因为插入排序每次只能操作一个元素，效率低。元素个数N，取奇数k=N/2，将下标差值为k的数分为一组（一组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为一组，构成有序序列，直到k=1，然后再进行直接插入排序。
- 选择排序
- 简单选择排序
选出最小的数和第一个数交换，再在剩余的数中又选择最小的和第二个数交换，依次类推
- 堆排序
以升序排序为例，利用小根堆的性质（堆顶元素最小）不断输出最小元素，直到堆中没有元素
1.构建小根堆
2.输出堆顶元素
3.将堆低元素放一个到堆顶，再重新构造成小根堆，再输出堆顶元素，以此类推
- 交换排序
- 冒泡排序
头尾进行冒泡，每次把最大的沉底，最小的浮上去，两边往中间靠1
- 快速排序
选择一个基准元素，比基准元素小的放基准元素的前面，比基准元素大的放基准元素的后面，这种动作叫分区，每次分区都把一个数列分成了两部分，每次分区都使得一个数字有序，然后将基准元素前面部分和后面部分继续分区，一直分区直到分区的区间中只有一个元素的时候，一个元素的序列肯定是有序的嘛，所以最后一个升序的序列就完成啦。
- 归并排序
将一个无序的数列一直一分为二，直到分到序列中只有一个数的时候，这个序列肯定是有序的，因为只有一个数，然后将两个只含有一个数字的序列合并为含有两个数字的有序序列，这样一直进行下去，最后就变成了一个大的有序数列
- 计数排序
找到最大的数，开个比最大的数大一点的数组，遍历每个元素，某个元素为k，则a[k]++,最好遍历数组a，a[k]等于多少就输出多少个k。只能处理整型数
稳定排序：冒泡排序，直接插入排序，归并排序，计数排序
稳定排序：待排序的记录序列中可能存在两个或两个以上关键字相等的记录。排序前的序列中Ri领先于Rj（即i<j）.若在排序后的序列中Ri仍然领先于Rj，则称所用的方法是稳定的。比如int数组[1,1,1,6,4]中a[0],a[1],a[2]的值相等，在排序时不改变其序列，则称所用的方法是稳定的。
不稳定排序：简单选择排序，快速排序，希尔排序，堆排序
3.具体排序讲解
3.1插入排序
直接插入排序
直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过 因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成。
第一层循环：遍历待比较的所有数组元素
第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。如果：selected > ordered，那么将二者交换。
#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v,int i) {
cout <<"第"<< i <<"次排序结果"<< ":";
for (int j = 0; j<v.size(); ++j) {
cout << v[j] << " ";
}
cout << endl;
}
void InsertSort(vector<int>& v) {
for (int i = 1; i < v.size(); ++i) {
// //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
if (v[i] < v[i - 1]) {
int end = i - 1;
int tmp = v[i];
while(end>=0) {
if (tmp < v[end]) {
v[end + 1] = v[end];
end--;
}
else
break;
}
v[end + 1] = tmp;
}
Print(v, i);
}
}
int main() {
vector<int> v;
v.push_back(10);
v.push_back(7);
v.push_back(9);
v.push_back(8);
v.push_back(4);
v.push_back(2);
InsertSort(v);
return 0;
}
希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
算法步骤：
1.选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2.按增量序列个数k，对序列进行k趟排序；
3.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v, int i) {
cout << "第" << i << "次排序结果" << ":";
for (int j = 0; j < v.size(); ++j) {
cout << v[j] << " ";
}
cout << endl;
}
void ShellSort(vector<int>& v) {
int size = v.size();
int gap = size;
while (gap > 1) {
gap = gap / 3 + 1;
for (int i = 0; i < size - gap; ++i) {
int end = i;
int tmp = v[end + gap];
while (end >= 0 && tmp < v[end]) {
v[end+gap] = v[end];
end -= gap;
}
v[end + gap] = tmp;
cout << "gap为" << gap << "时";
Print(v,i);
}
cout << endl;
}
}
int main() {
vector<int> v;
v.push_back(10);
v.push_back(7);
v.push_back(9);
v.push_back(8);
v.push_back(4);
v.push_back(2);
ShellSort(v);
return 0;
}
3.2选择排序
简单选择排序
简单选择排序的实现思想：比较+交换
在一个无序数组中选择出每一轮中最值元素，然后把这一轮中最前面的元素和min交换，最后面的元素和max交换；然后缩小范围(begin++,end–),重复上面步骤，最终得到有序序列（升序）。
#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v,int i) {
cout <<"第"<< i <<"次排序结果"<< ":";
for (int j = 0; j<v.size(); ++j) {
cout << v[j] << " ";
}
cout << endl;
}
void Selectsort(vector<int>& v) {
size_t size = v.size();
int begin = 0;
int end = size - 1;
int j = 0;
while (begin < end) {
int min = begin,max = begin;
//选择每一轮的最值元素
for (int i = begin; i <=end; ++i) {
if (v[min]>v[i])
min = i;
if (v[max]<v[i])
max = i;
}
//最前面的元素和min交换，最后面的元素和max交换
swap(v[min], v[begin]);
////如果首元素是最大的，则需要先把min 和 max的位置一换，再交换，否则经过两次交换，又回到原来的位置
if (max==begin) {
max = min;
}
swap(v[max], v[end]);
++j;
++begin;
--end;
Print(v, j);
}
}
int main() {
vector<int> v;
v.push_back(10);
v.push_back(7);
v.push_back(9);
v.push_back(8);
v.push_back(4);
v.push_back(2);
Selectsort(v);
return 0;
}
堆排序
堆的概念
堆：本质是一种数组对象。特别重要的一点性质：任意的叶子节点小于（或大于）它所有的父节点。对此，又分为大顶堆和小顶堆：
大顶堆要求节点的元素都要大于其孩子。
小顶堆要求节点元素都小于其左右孩子。
两者对左右孩子的大小关系不做任何要求。利用堆排序，就是基于大顶堆或者小顶堆的一种排序方法。下面，我们通过大顶堆来实现。
基本思想：堆排序可以按照以下步骤来完成：
- 首先将序列构建称为大顶堆；（这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值）
- 取出当前大顶堆的根节点，将其与序列末尾元素进行交换；（此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
- 对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
- 重复2.3步骤，直至堆中只有1个元素为止
#include<iostream>
#include<vector>
using namespace std;
void Adjustdown(int* a, int root, int n) {
int child = root * 2 + 1;//左孩子
while (child < n) {
if ((child + 1 )< n && a[child + 1] > a[child])
child++;
if (a[child] > a[root]) {
swap(a[child], a[root]);
root = child;
child = root * 2 + 1;
}
else
break;
}
}
int* Heapsort(int* a, int n) {
//构建堆 从最后一个非叶子节点开始
for (int i = (n - 1) / 2; i >= 0; i--) {
Adjustdown(a, i, n);
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << endl;
}
int end = n - 1;
while (end > 0) {
swap(a[0], a[end]);
Adjustdown(a, 0, end); // end其实就是不算后面的一个元素，原因是最后一个节点已经是最大的
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << endl;
end--;
}
return a;
}
int main() {
int a[] = { 2,5,1,7,9,8,3,6 };
int n = (sizeof(a)) / sizeof(int);
Heapsort(a, n);
for (int i = 0; i < n; ++i) {
cout << a[i] << " " ;
}
return 0;
}
3.3交换排序
冒泡排序
冒泡遍历所有的数据，每次对相邻元素进行两两比较，如果顺序和预先规定的顺序不一致，则进行位置交换；这样一次遍历会将最大或最小的数据上浮到顶端，之后再重复同样的操作，直到所有的数据有序。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。
#include<iostream>
#include<vector>
using namespace std;
void Bubblesort(int* a, size_t n) {
for (int i = 0; i < n-1; ++i) {
for (int j = 0; j < n-1-i; ++j) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
int main() {
int a[] = { 2,5,1,7,9,8,3,6 };
int n = (sizeof(a)) / sizeof(int);
Bubblesort(a, n);
for (int i = 0; i < n; ++i) {
cout << a[i] << " " ;
}
return 0;
}
优化：设置一个变量判断exchange判断序列是否为升序序列，如为升序则直接输出。
#include<iostream>
#include<vector>
using namespace std;
void Bubblesort(int* a, size_t n) {
for (int i = 0; i < n - 1; ++i) {
int exchange = 0;//设置一个变量判断是否为升序序列 优化冒泡排序
for (int j = 0; j < n-1-i; ++j) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
exchange = 1;//exchang改变说明 其不是一个标准的升序序列
}
}
if (exchange == 0)//exchange没变 说明其是一个标准的升序序列 跳出循环
break;
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << endl;
}
}
int main() {
int a[] = { 2,5,1,7,9,8,3,6 };
int n = (sizeof(a)) / sizeof(int);
Bubblesort(a, n);
return 0;
}
快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：
- 左右指针法
- 挖坑法
- 前后指针法
左右指针法
1．将数组的最后一个数right作为基准数key。
2．分区过程:从数组的首元素begin开始向后找比key大的数（begin找大）；end开始向前找比key小的数（end找小）；找到后然后两者交换（swap）,直到begin >= end终止遍历。最后将begin和最后一个数交换（ 这个时候end不是最后一个位置），即 key作为中间数（左区间都是比key小的数，右区间都是比key大的数）
3．再对左右区间重复第二步，直到各区间只有一个数。
//左右指针法
int Partsort1(int* a, int left, int right) {
int begin = left;
int end = right;
int key = right;
while (begin < end) {
while (begin < end && a[begin] <= a[key])
begin++;
while (begin < end && a[end] >= a[key])
end--;
swap(a[begin], a[end]);
}
swap(a[begin], a[right]);
return begin;//返回中间位置
}
挖坑法
- 定义两个指针left指向起始位置，right指向最后一个元素的位置,然后指定一个基数key（right）,作为坑。
- left寻找比基数（key）大的数字，找到后将left的数据赋给right，left成为一个坑，然后right寻找比基数（key）小的数字，找到将right的数据赋给left，right成为一个新坑，循环这个过程，直到begin指针与end指针相遇，然后将key返回给那个坑（最终：key的左边都是比key小的数，key的右边都是比key大的数），然后进行递归操作。
//挖坑法
int Partsort2(int* a, int left, int right) {
int key = a[right];//初始坑
while (left < right) {
while (left < right && a[left] <= key)
left++;
a[right] = a[left];//left作为新坑
while (left < right && a[right] >= key)
right--;
a[left] = a[right];//right作为新坑
}
a[left] = key;////将key赋值给left和right的相遇点，保持key的左边都是比key小的数，key的右边都是比key大的数
return left;//最终返回中间位置
}
前后指针法
- 定义两个指针，一前一后，cur（前）指向起始位置，prev（后）指向cur的前一个位置；选择数组最后一个元素作为key（right）
- 实现过程：cur找比key小的数，prev在cur没有找到的情况下，一直不动（即保证prev一直指向比key大的数）；直到cur找到比key小的数（+ +prev && prev != cur时）然后++cur,prev仍然不动。
- 直到cur走到right前一个位置，终止循环。最后++prev，交换prev和right的值。返回中间位置prev。最后再继续递归。
//前后指针法
int Partsort3(int* a, int left, int right) {
int cur = left;
int prev = left - 1;
int key = a[right];
while (cur < right) {
if (a[cur] < key && ++prev!=cur) {
swap(a[cur], a[prev]);
}
++cur;
}
swap(a[++prev], a[right]);//++prev左边比key小 右边比key大
return prev;////返回中间位置
}
递归实现：
#include<iostream>
#include<vector>
using namespace std;
//左右指针法
int Partsort1(int* a, int left, int right) {
int begin = left;
int end = right;
int key = right;
while (begin < end) {
while (begin < end && a[begin] <= a[key])
begin++;
while (begin < end && a[end] >= a[key])
end--;
swap(a[begin], a[end]);
}
swap(a[begin], a[right]);
return begin;//返回中间位置
}
//挖坑法
int Partsort2(int* a, int left, int right) {
int key = a[right];//初始坑
while (left < right) {
while (left < right && a[left] <= key)
left++;
a[right] = a[left];//left作为新坑
while (left < right && a[right] >= key)
right--;
a[left] = a[right];//right作为新坑
}
a[left] = key;////将key赋值给left和right的相遇点，保持key的左边都是比key小的数，key的右边都是比key大的数
return left;//最终返回中间位置
}
//前后指针法
int Partsort3(int* a, int left, int right) {
int cur = left;
int prev = left - 1;
int key = a[right];
while (cur < right) {
if (a[cur] < key && ++prev!=cur) {
swap(a[cur], a[prev]);
}
++cur;
}
swap(a[++prev], a[right]);//++prev左边比key小 右边比key大
return prev;//返回中间位置
}
//递归
void Quicksort(int* a, int left, int right) {
if (left >= right)
return;
int mid = Partsort1(a, left, right);
Quicksort(a, left, mid - 1);
Quicksort(a, mid + 1, right);
}
int main() {
int a[] = { 2,5,1,7,9,8,3,6 };
int n = (sizeof(a)) / sizeof(int);
Quicksort(a, 0, n - 1);
for (int i = 0; i < n; ++i) {
cout << a[i] << " " ;
}
return 0;
}
扫一扫
2878
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
