学习笔记-排序算法
排序
- 1、冒泡排序
- 2、选择排序
- 3、插入排序
- 4、快速排序
- 5、堆排序
- 6、希尔排序
- 7、计数排序
- 8、基数排序
- 9、桶排序
- 10、归并排序
- 11、测试
- x、排序
参考博文：各种排序-从这篇文章中记录了学习笔记（搬运过来），掌握了原理，代码一定要结合图解手撸一遍。
1、冒泡排序
1.1 算法思想
- 比较相邻的元素，如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从第一对开始，一直到最后一对，做完后，最后的元素会是最大的元素。
- 针对所有的元素重复上面的步骤，除排序好的。
- 持续对越来越少的元素重复上述步骤，直到哪次没有任何一对数字需要比较或者是交换。
1.2 图解
1.3 代码
//冒泡排序
void bubbleSort(int* arr, int len)
{
for (int i = 0; i < len - 1; i++) //表示要找到len-1个最大数
{
for (int j = 0; j < len - 1 - i; j++) //每次最大数都遍历一遍，找到最大值
{
if (arr[j] > arr[j + 1])
swap(arr[j], arr[j + 1]);
}
}
}
2、选择排序
2.1 算法思想
- 在未排序的序列中找到
最小（大）元素，存放到排序序列的起始位置。 - 从剩下
未排序元素中继续寻找最小（大）元素，然后放到自己已排序的序列的末尾。 - 以此类推，直到所有元素排序完毕。
时间复杂度O(n^2)
2.2 图解
2.3 代码
//选择排序（升序）
void selectionSort(int* arr,int len)
{
//从第一个位置找，共找len-1个最小数
for (int i = 0; i < len - 1; i++)
{
int min = i;//min为最小值位置 初始认为i处是最小
//接下来找到最小数放到第i个位置
for (int j = i + 1; j < len; j++)
{
if (arr[j] < arr[min])
min = j; //如果找到更小的，就记录当前位置
}
swap(arr[i], arr[min]); //最后将未排序中找到的最小值和第i个位置交换
}
}
3、插入排序
3.1 算法思想
将无序元素插到有序元素中去
- 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
- 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置（腾位置）；
- 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 步骤5: 将新元素插入到该位置后；
- 步骤6: 重复步骤2~5。
时间复杂度O(n^2),不稳定,
3.2 图解
3.3 代码
//插入排序（升序）
void insertSort(int* arr,int len)
{
//第1个位置已叫排序，从第2个位置到最后一个位置插入len-1次
for (int i = 1; i < len; i++)
{
//第i个位置装配，开始找插入位置
int temp = arr[i];
int j = i - 1;
while (j >= 0 && temp < arr[j])//条件分两种情况：1、插入中间 2、插入头部
{
arr[j + 1] = arr[j];
j--;
}
//j位置的值比temp小，就插入j+1位置
arr[j + 1] = temp;
}
}
4、快速排序
4.1 算法思想
- 选第一个数为标准。
- 将比基准小的数据交换到前面，比基准大的交换到后面
- 对左边的空间和右边的空间重复，直到各区间只有一个数字
4.2 图解
4.3 代码
//快速排序（升序） 使用了递归方法，递归函数详细描述一层运算
void quickSort(int* arr,int left,int right)
{
//设置迭代截至条件
if (left >= right) return;
//两个标志承接左右下标 设置初始基准值
int begin = left;
int end = right;
int key = arr[end];
//开始当前一层的运算
while (begin < end)
{
//基准左边一般为小 找大
while (begin < end && arr[begin] <= key) begin++;
arr[end] = arr[begin];//如果找到大的，将其提取到右边end处
//基准右边一般为大 找小
while (begin < end && arr[end] >= key) end--;
arr[begin] = arr[end];//如果找到小的，将其提取到左边begin处
}
arr[end] = key;//最后将基准放在begin和end交界处
//开启下一层运算
quickSort(arr, left, end - 1);//基准左边排序交给迭代函数
quickSort(arr, end + 1, right);//基准右边排序交给迭代函数
}
5、堆排序
5.1 算法思想
- 如果要从小到大排序，建立大堆，根节点大于左右子树。
- 将根结和最后一个元素交换，并且树的元素个数减1。
- 重复1~2，直到只剩一个元素。
参考博文：堆排序(C语言)
定义了以下几种操作：
（1）最大堆调整（Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
（2）创建最大堆（CreateHeap）：将堆中的所有数据重新排序
（3）堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算
堆是一个近似完全二叉树的结构
数组a[k]与二叉树的性质：
父节点：(k-1)/2
左子节点：2k+1
右子节点：2k+2
5.2 图解
5.3 代码
//堆排序
//子函数：最大对调整 迭代 （前提是其子节点已经成为最大堆，检验这个父节点有没有实力，没有则为其安排在适合的位置，谁有能力谁上）
void heapify(int* arr,int len,int k)
{
//迭代继续条件 检验父节点
if (k < len)
{
int max = k; //假设父节点最大
int s1 = 2 * k + 1; //子节点索引
int s2 = 2 * k + 2; //子节点索引
//看看子节点有没有更强的
if (s1<len && arr[s1]>arr[max]) max = s1;
if (s2<len && arr[s2]>arr[max]) max = s2;
//如果有强的，子节点上，父节点继续和下边儿比较
if (max != k)
{
swap(arr[max], arr[k]);
heapify(arr, len, max);//退下来的父节点继续看看这个位置他能把握住吗
}
}
}
//堆排序函数
void heapSort(int* arr, int len)
{
//1、创建最大堆 根节点为最大数
int last_node = len - 1;
int last_parent = (last_node - 1) / 2;//最后一个父节点
//从低向上 创建最大堆 每一小步都是用最大堆调整
for (int i = last_parent; i >= 0; i--)
heapify(arr, len, i);
//2、每次根节点为最大数 放后边儿 升序排序
for (int i = len - 1; i >= 0; i--)
{
swap(arr[0], arr[i]);
heapify(arr, i, 0);//这里剩余数量正好是i 对新的根节点重新调整审视（因为已经创建后的最大堆，除了根节点，其他都符合最大堆性质）
}
}
6、希尔排序
6.1 算法思想
将数组元素分成若干组，每组分别进行插入排序，使整个数组逐渐变成部分有序数组，再慢慢减少所分的组数，最终合并成一个组 。
将数组多次分组，分别进行插入排序—改进的插入排序。
参考博文：排序算法之希尔排序、希尔排序C++实现
6.2 图解
6.3 代码
//希尔排序
void shellSort(int* arr,int len)
{
int group = len / 2;//分组数
//不同组数下，对每组插入排序
while (group >= 1)
{
//希尔排序下的插入排序
//外层循环 确定要选哪些点插入
for (int i = group; i < len; i++)
{
int temp = arr[i];//要插入的值存入临时变量
int j = i - group;//插入已排好序的数组用到的指针
//内层循环 插入
while (j>=0&&temp<=arr[j])
{
arr[j + group] = arr[j];//正常都是慢慢排查
j = j - group;
}
arr[j + group] = temp;//找到位置了 插入
}
group /= 2;//该换小点儿的分组了
}
}
7、计数排序
7.1 算法思想
- 1、找出待排序的数组
最大和最小的元素 - 2、统计数组中每个值为
i∈[min:1:max]的元素出现的个数，存入数组c的第i-min项 - 将下标+min的值根据在数组c中的个数存到
原数组中。
本算法图解更容易理解
7.2 图解
7.3 代码
时间复杂度：O(n+k)，n容量的原数组，k容量的计数数组，实际分别遍历了两个数组，所有好坏情况都是O(n+k)。
空间复杂度：O(k)，新建了k容量的计数数组。
//计数排序
void countSort(int* arr, int len)
{
//1、找最大最小值
int min = arr[0];
int max = arr[0];
for (int i = 0; i < len; i++)
{
if (arr[i] < min) min = arr[i];
if (arr[i] > max) max = arr[i];
}
//2、创建计数数组
int len_count = max - min + 1;//计数数组长度
int* arr_count = new int[len_count];
for (int i_count = 0; i_count < len_count; i_count++)
arr_count[i_count] = 0;
for (int i = 0; i < len; i++)//核心，为每个数计数
{
arr_count[arr[i] - min] += 1;
}
//3、计数数组-按顺序放回->原数组
int i_total = 0;
for (int i_count = 0; i_count < len_count; i_count++)
{
for (int i_temp = 0; i_temp < arr_count[i_count]; i_temp++)
{
arr[i_total++] = min + i_count;//装入真实的数
}
}
}
8、基数排序
8.1 算法思想
- 取得数组中的最大数，并取得
位数。 - 根据个位数值大小，对数组进行排序（实际放
0~9的桶里进行计数排序）； - 重复上一步骤，依次根据更高位数值进行排序，直至到达最高位；
参考博文：C++排序算法之基数排序
8.2 图解
8.3 代码
//基数排序
//获得数组中最大数的位数
int maxBit(int* arr, int len)
{
int bit_num = 0;
for (int i = 0; i < arr[i]; i++)//遍历数组
{
//获取当前数的位数
int temp = arr[i];
int bit_temp = 0;
while (temp > 0)
{
temp /= 10;
bit_temp++;
}
//比较是否是最大位数
if (bit_temp > bit_num)
bit_num = bit_temp;
}
return bit_num;
}
//基数排序的简单实现
void radixSort(int* arr, int len)
{
int bit_max = maxBit(arr, len); //获得数组中最大数的位数
vector<vector<int>> buckets(10); //新建10个桶
int r = 1; //作为除数
for (int i_bit = 0; i_bit < bit_max; i_bit++)//从低位向高位遍历
{
//1、遍历数组，将数放桶里
for (int i = 0; i < len; i++)
{
int num_temp = (arr[i] / r) % 10;//取特定的那一位
buckets[num_temp].push_back(arr[i]);
}
//2、遍历桶，按桶的顺序放回数组
int i_origin = 0;
for (int i_bucket = 0; i_bucket < 10; i_bucket++)
{
if (!buckets[i_bucket].size()) continue;
for (vector<int>::iterator itr_num = buckets[i_bucket].begin(); itr_num != buckets[i_bucket].end(); itr_num++)
{
arr[i_origin++] = *itr_num;
}
buckets[i_bucket].clear();//用完顺便清空，以便下次再用。
}
r *= 10;
}
}
9、桶排序
9.1 算法思想
是计数排序的进化版
- 设置一个定量的数组当作
空桶子。 - 寻访序列，并且把项目一个一个
放到对应的桶子去（将数组分段划分、按位数划分等）。 - 对每个非空的桶子进行
排序（其他适合小范围的排序，如插入排序）。 - 从不是空的桶子里把项目再放回原来的序列中。
参考博文：C/C++桶排序
9.2 图解
9.3 代码
//桶排序
void bucketSort(int* arr, int len)
{
//寻找最大最小值
int min_value = arr[0];
int max_value = arr[0];
for (int i = 1; i < len; i++)
{
if (arr[i] < min_value) min_value = arr[i];
if (arr[i] > max_value) max_value = arr[i];
}
//初始化桶，将数组的数据按某一分组装入桶中
int bucketsize = 5; //桶大小
int buckets_num = (max_value - min_value) / bucketsize + 1; //桶数量
vector<vector<int>> buckets(buckets_num);
for (int i = 0; i < len; i++)
{
int index = (arr[i] - min_value) / bucketsize;
buckets[index].push_back(arr[i]);
}
//对每个桶排序，装回原数组
int i_origin = 0; //全程记录原数组索引
for (int i_bucket = 0; i_bucket < buckets_num; i_bucket++)
{
if (!buckets[i_bucket].size()) continue;//排除空桶
//给当前桶排序（插入排序）
for (int i_sort = 1; i_sort < buckets[i_bucket].size(); i_sort++)
{
int temp_sort = buckets[i_bucket][i_sort];
int j_sort = i_sort - 1;//关键索引
while (j_sort >= 0 && temp_sort < buckets[i_bucket][j_sort])
{
buckets[i_bucket][j_sort + 1] = buckets[i_bucket][j_sort];
j_sort--;
}
buckets[i_bucket][j_sort + 1] = temp_sort;
}
//将排好序的桶数据放回原数组
for (int i_sort = 0; i_sort < buckets[i_bucket].size(); i_sort++)
{
arr[i_origin++] = buckets[i_bucket][i_sort];
}
}
}
10、归并排序
10.1 算法思想
- 把长度为
n的输入序列分成两个长度为n/2的子序列； - 对这两个子序列分别采用归并排序（
递归）； - 将两个排序好的子序列
合并成一个最终的排序序列。
10.2 图解
10.3 代码
//归并排序
//归并执行
void mergeExtract(int* arr, int left, int right, int* temp)
{
//递归结束条件
if (left >= right)
return;
//两个子序列进入下一递归
int mid = left + (right - left) / 2;
mergeExtract(arr, left, mid, temp);
mergeExtract(arr, mid+1, right, temp);
//返回两个排好序的子序列，归并存于temp
//1、初始化4个指针
int begin_1 = left, end_1 = mid;
int begin_2 = mid + 1, end_2 = right;
//2、融合两个子序列大部分，两个begin指针变动
int i_temp = left;
while (begin_1 <= end_1 && begin_2 <= end_2)
{
//将较小的存入temp
if (arr[begin_1] < arr[begin_2]) temp[i_temp++] = arr[begin_1++];
else temp[i_temp++] = arr[begin_2++];
}
//3、收尾工作，第1个子序列/第2个子序列可能剩下。
while (begin_1 <= end_1)
temp[i_temp++] = arr[begin_1++];
while (begin_2 <= end_2)
temp[i_temp++] = arr[begin_2++];
//将temp加入arr中
for (int i = left; i <= right; i++)
arr[i] = temp[i];
}
//归并主函数
void mergeSort(int* arr, int len)
{
int* temp = new int[len]; //temp做arr的辅助
mergeExtract(arr, 0, len - 1, temp);
delete[] temp; //释放内存
}
11、测试
#include /--------------------------------------------------------------------------------------------------------------------------------/
x、排序
x.1 算法思想
x.2 图解
x.3 代码