常见的排序算法
插入排序：
直接插入排序、希尔排序
选择排序：
选择排序、堆排序
交换排序：
冒泡排序、快速排序
归并排序：
归并排序
=
插入排序
直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已
经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的
排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置
上的元素顺序后移。
- 总结：
- 元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)，它是一种稳定的排序算法
- 稳定性：稳定
- 源码：
void insertsort(int *array, int len){
int v,j;
for (int i = 1; i < len; i++){
v = array[i];
for ( j = i - 1; j>=0; j--){
if (array[j] > v){
array[j + 1] = array[j];
}
else {
break;
}
}
array[j + 1] = v;
}
}
选择排序
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据
元素排完
- 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
- 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
- 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定**
源码：
void Selection_sort(vector<int>::iterator begin, vector<int>::iterator end)
{
for (auto i = begin; i != end; i++) //
{
for (auto j = i; j != end; j++) //每次都和地址为i的数据进行比较
{
if (*i > *j) //*i 表示第i个数，也就是第一个数
{
int tmp = *i; //将值交换了，但是地址不变
*i = *j;
*j = tmp;
}
}
}
}
堆排序：
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过
堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
特性总结：
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
源码：
public static void heapify(int[] array, int RootNode, int size)
{
if (RootNode < size)
{
int left = 2 * RootNode + 1; //左子树和右子树的位置
int right = 2 * RootNode + 2;
int max = RootNdoe; //当前的根节点看为最大的节点
if (left < size)
{
if (array[max] < array[left]) //当左孩子比最大的节点大时，记录左孩子的位置
{
max = lift;
}
}
if (right < size)
{
if (array[max] < array[right]) //当右孩子比最大的节点大时，记录有孩子的位置
{
max = right;
}
}
if (max != RootNode) //当最大的节点位置不是根节点位置，则交换两个位置的值
{
int tmp = array[max];
array[max] = array[RootNode];
array[RootNode] = tmp;
heapify(array, max, size); //继续比较，完成下一次的建堆。
}
}
}
冒泡排序
算法原理：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
源码：
void bubbleSort(int a[], int len)
{
for (int i = 0; i < len - 1; i++) // 外循环为排序趟数，len个数进行len-1趟排序
{
for (int j = 0; j < len - 1 - i; j++) //内循环为每趟比较的次数，第i趟比较len-i次
{
if (a[j] > a[j + 1]) //相邻元素比较，若逆序则交换（升序为左大于右，降序反之）
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
快速排序
基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
特性总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序；
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
源码：
#include<iostream>
using namespace std;
void Swap(int *p, int *q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
int Partion(int *array, int left, int right)
{
int begin = left;
int end = right - 1;
int key = array[right - 1];
while (begin < end)
{
//从左往右比基准值大的元素，找到之后停止
while (begin < end&&array[begin] <= key)
{
begin++;
}
//从右往左找比基准值小的元素，找到之后停止
while (begin < end&&array[end] >= key)
{
end--;
}
if (begin != end)
{
Swap(&array[begin], &array[end]);
}
}
if (begin != right - 1) //将begin与end相等位置的数据与基准值交换 此值一定大于基准值
{
Swap(&array[begin], &array[right-1]);
}
return begin;
}
void QuickSort(int *arraay, int left, int right)
{
if (right - left > 1)
{
//按照基准值将区间分割成左右两部分
//左侧小于基准值，右侧大于基准值
int div = Partion(arraay, left, right); //div是基准值
QuickSort(arraay,left,div); //基准值左侧排序
QuickSort(arraay, div, right); //基准值右侧排序
}
}
int main()
{
int array[] = { 3,4,2,9,1,7,6,0,8,5 };
int left = 0;
int right=sizeof(array)/sizeof(array[0]);
QuickSort(array,left,right);
for (int i = 0; i < 10; i++)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
归并排序：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
特性总结
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
源码：
#include<malloc.h>
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;
void MergeData(int *array, int left, int mid, int right,int *temp)
{
int begin1 = left, end1 = mid;
int begin2 = mid, end2 = right;
int index = left;
while (begin1<end1&&begin2<end2)
{
if (array[begin1] < array[begin2])
{
temp[index++] = array[begin1++];
}
else
temp[index++] = array[begin2++];
}
while (begin1<end1)//说明2里面的元素搬移完了
{
temp[index++] = array[begin1++];
}
while (begin2 < end2)
{
temp[index++] = array[begin2++];
}
}
void _MergeSort(int *array, int left, int right, int *temp)
{
//申请一个新的空间
if (right - left > 1) //剩下一个元素的时候就不用排了
{
int mid = left + (right - left) / 2;
//[left,mid)
//[mid,right)
_MergeSort(array, left, mid,temp); //只有下层两个有序的情况下才可以归并。
_MergeSort(array, mid, right,temp);
MergeData(array, left, mid, right,temp);
memcpy(array+left, temp+left, sizeof(int)*(right - left));//按字节拷贝
}
}
void MergeSort(int *array,int size)
{
int *temp = (int*)malloc(sizeof(int)*size);
if (NULL == temp)
{
assert(0);
return;
}
_MergeSort(array, 0, size, temp);
free(temp);
}
int main()
{
int array[] = { 3,4,2,9,1,7,6,0,8,5 };
int left = 0;
int right = sizeof(array) / sizeof(array[0]);
MergeSort(array,sizeof(array)/sizeof(array[0]));
for (int i = 0; i < 10; i++)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
扫一扫
86
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
