本文介绍了七种基础的排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序和快速排序。这些排序算法各有特点，如冒泡排序通过不断交换相邻元素实现，选择排序每次选取未排序部分的最小值，插入排序则通过移动元素找到合适位置，希尔排序利用间隔排序，堆排序构建大顶堆，归并排序采用分治策略，快速排序则是以基准值划分数组。
七大排序算法
排序过程中，后面的排序不会更改之前已经排序后的数据的顺序，则称这种排序算法是稳定的；否则称为不稳定的
1.冒泡排序
步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
步骤2:对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
步骤3:针对所有的元素重复以上的步骤，除了最后一个；
步骤4: 重复步骤1~3，直到排序完成。
#include<iostream>
using namespace std;
//冒泡排序
void bubble(int arr[], int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
swap(&arr[j], &arr[j + 1]);
}
}
}
}
int main(){
int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
int len = (int) sizeof(arr) / sizeof(*arr);
bubble(arr, len);
printf("排序后的结果:\n");
for (int i = 0; i < len; i++)
{
cout << arr[i] << ' ';
cout << endl;
}
return 0;
}
2. 选择排序
依次选出数组最小的数放到数组的前面。首先从数组的第二个元素开始往后遍历，找出最小的数放到第一个位置。再从剩下数组中找出最小的数放到第二个位置。以此类推，直到数组有序。
//选择排序
void selet(int arr[], int len)
{
for (int i = 0; i < len - 1; i++) //n个元素，执行n-1步选择
{
int max = 0;
for (int j = 1; j < len - i; j++) //查找未排序的元素
{
if (arr[j] > arr[max])
{
max = j; //找到未排序元素中的最大值
}
}
if (max != len - i - 1) //把最大值和最后一个元素交换
{
swap(&arr[max], &arr[len - i - 1]);
}
}
}
int main()
{
int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
int len = (int) sizeof(arr) / sizeof(*arr);
selet(arr, len);
printf("排序后的结果:\n");
for (int i = 0; i < len; i++)
{
cout << arr[i] << ' ';
cout << endl;
}
return 0;
}
3. 插入排序
和交换排序不同的是它不用进行交换操作，而是用一个临时变量存储当前值。当前面的元素比后面大时，先把后面的元素存入临时变量，前面元素的值放到后面元素位置，再到最后把其值插入到合适的数组位置。所以相应的辅助空间为O（1）。
#include<iostream>
using namespace std;
//插入排序
void Insersort(int arr[], int len)
{
int cur = 0;
int pre = 0;
for (int i = 1; i < len; i++)
{
cur = arr[i];
pre = i - 1;
while (pre >= 0 && arr[pre] > cur)
{
arr[pre + 1] = arr[pre];
pre--;
}
arr[pre + 1] = cur;
}
}
int main()
{
int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
int len = (int) sizeof(arr) / sizeof(*arr);
Insersort(arr, len);
printf("排序后的结果:\n");
for (int i = 0; i < len; i++)
{
cout << arr[i] << ' ';
cout << endl;
}
return 0;
}
4. 希尔排序
先将整个待排序的记录序列分割成为若干子序列分别进行插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次插入排序。
#include<stdio.h>
void shellsort(int arr[], int len)
{
int gap = len / 2;
for (; gap > 0; gap = gap / 2) //增量
{
for (int i = gap; i < len; i++)
{
int temp = arr[i];
int j = 0;
for (j = i - gap; j >= 0 && arr[j]>temp;j -=gap)
{
arr[j + gap] = arr[j];
}
arr[j + gap] = temp;
}
}
}
int main()
{
int arr[] = { 163,161,155,167,170,180,159,162 };
int len = sizeof(arr) / sizeof(arr[0]);
shellsort(arr, len);
for (int i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
5. 堆排序
把数组构造成一个大顶堆（父亲节点大于其子节点），然后把堆顶（数组最大值，数组第一个元素）和数组最后一个元素交换，这样就把最大值放到了数组最后边。把数组长度n-1,再进行构造堆，把剩余的第二大值放到堆顶，输出堆顶(放到剩余未排序数组最后面)。依次类推，直至数组排序完成。
#include<iostream>
using namespace std;
//从最后一个非叶子节点开始，求出每个小堆的最大值放在小堆的堆顶，直到根节点。
//这样，根节点的值则为整个堆里面的最大值，但这并不意味着它是一个大根堆。
//堆排序
void GetMaxValue(int tree[], int heapLen)
{
for (int i = (heapLen - 1) / 2; i >= 0; i--)
{
int max = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left<heapLen && tree[left]>tree[max])
{
max = left;
}
if (right<heapLen && tree[right]>tree[max])
{
max = right;
}
if (max != i)
{
swap(tree[max], tree[i]);
}
}
}
void HeapSort(int arr[], int len)
{
int heapLen = len;
for (int i = 0; i < len; i++)
{
GetMaxValue(arr, heapLen);//使堆顶元素是最大值
swap(arr[0], arr[heapLen - 1]);
heapLen--;//在交换堆顶元素和数组最后一个元素的位置之后，下次堆的长度-1
}
}
int main()
{
int arr[10] = { 1,3,7,85,3,6,8,2,9,12 };
int len = 10;
cout << "排序前：" << endl;
for (int i = 0; i < 10; ++i)
{
cout << arr[i] << " ";
}
HeapSort(arr, len);//堆排序
cout << endl << "排序后：" << endl;
for (int j = 0; j < 10; j++)
{
cout << arr[j] << " ";
}
return 0;
}
6. 归并排序
归并算法应用到分治策略，简单说就是把一个大的问题分解成易于解决的小问题后一个个解决，最后在把小问题的一步步合并成总问题的解。这里的排序应用递归来把数组分解成一个个小数组，直到小数组的数有序，再把有序的小数组两两合并而成有序的大数组。
void mergeadd(int arr[], int left, int mid, int right, int*temp)
{
int i = left; //指向左边数组最小的元素位置指
int j = mid; //向右边数组最小的元素位置
int k = left; // 临时数组的下标
while (i < mid && j <= right)
{
if (arr[i] < arr[j])
{
temp[k++] = arr[i++];
}
else
{
temp[k++] = arr[j++];
}
}
while (i < mid)
{
temp[k++] = arr[i++];
}
while (j <= right)
{
temp[k++] = arr[j++];
}
//把temp中的内容拷贝到arr 数组中
memcpy(arr + left, temp+left, sizeof(int) * (right - left + 1));
}
//用分而治之在归并排序
void mergeSort(int arr[], int left, int right, int* temp)
{
int mid = 0;
if (left < right)
{
mid = left + (right - left) / 2;
mergeSort(arr, left, mid, temp);
mergeSort(arr, mid+1, right ,temp);
mergeadd(arr,left,mid+1,right,temp);
}
}
int main()
{
int arr[] = { 10,13,16,15,2,4,5,8 };
int len = sizeof(arr) / sizeof(arr[0]);
int* temp = new int[len];
//int mid = len / 2;
//归并排序
mergeSort(arr, 0, len - 1, temp);
//mergeadd(arr, 0,mid,len-1,temp);//下标0-3，4-7
for (int j = 0; j < len; j++)
{
cout << arr[j] << " ";
}
return 0;
}
7. 快速排序
快速排序也是使用分治法的思想，所以在实现时会采用递归的方法
选取一个基准值（以数组最左位置的值为例），把比基准值小的数值放到其左边，比基准值大的数值放到右边，然后根据基准值的位置分成左右子数组，子数组再使用此方法排序。递归下去，最终获取有序数组。
#include<stdio.h>
#include<stdlib.h>
int partion(int arr[], int low, int higt)
{
int i = low;
int j = higt;
int base = arr[low];
if (low < higt)
{
while (i < j)
{
while (i < j && arr[j] >= base)
{
j--;
}
if (i < j)//右边找到小于基数的数
{
arr[i] = arr[j];
i++;
}
while (i<j && arr[i]<base)
{
i++;
}
if (i < j) //左边找到大于基数的数
{
arr[j--] = arr[i];
}
}
arr[i] = base;
}
return i;
}
//快速排序
void quicksort(int* arr, int low, int higt)
{
if (low < higt)
{
int index = partion(arr, low, higt); //基数所在的位置
quicksort(arr, low, index - 1);
quicksort(arr, index + 1, higt);
}
}
int main()
{
int arr[] = { 160,163,171,156,164,155,170,165 };
int len = sizeof(arr) / sizeof(arr[0]);
int index = partion(arr, 0, len-1);
printf("分区完毕，基数下标：%d\n", index);
for (int i = 0; i < len; i++)
{
printf("%d,", arr[i]);
}
quicksort(arr, 0, len - 1);
printf("执行快排的结果：\n");
for (int i = 0; i < len; i++)
{
printf("%d,", arr[i]);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
