按时间性能分
o(n*logn)的排序:快排,归并,堆排序;
o(n2)的排序:直接插入,选择,冒泡排序;
还有一个不确定的希尔排序;
1.直接插入排序
算法思想:很简单,类似于摸扑克牌,在有序的数字区间内插入一个数字,仍让它有序;
代码实现:
void insertsort(int *a, int n)
{
for (int i = 1; i < n; i++)
{
int end = i - 1;
int tmp = a[end + 1];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
a[end + 1] = tmp;
}
}
}
时间复杂度分析:
最好:本身就是有序的,此时只需比较n-1次,时间复杂度为O(N);
最坏:数组是逆序的时候,是一个等差数列O(N2)
2.希尔排序
希尔排序是插入排序的改进版本;
算法思想:让数据更快的跳入到后面,先对数组进行预排序,使他接近有序,再用直接插入排序对它进行排序;
代码实现:
void shellsort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
//gap /= 2;
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
时间复杂度:
稳定性:希尔排序是一种不稳定的排序;
eg 3 5 10 8 7 2 8 1 20 6
若 gap=2,则一趟下来的排序为
3 1 7 2 8 5 10 6 20 8
3.简单选择排序
简单选择排序是一种最朴实无华的算法,选出最大的值放到右边,最小的值放到左边,也可以说是最low的算法
代码实现
void SelectSort(int* a, int n)
{
int left = 0, right = n - 1;
while (left < right)
{
int mini = left, maxi = left;
for (int i = left + 1; i <= right; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
swap(&a[left], &a[mini]);
// 如果left和maxi重叠,交换后修正一下
if (left == maxi)
{
maxi = mini;
}
swap(&a[right], &a[maxi]);
++left;
--right;
}
}
时间复杂度O(N2)
选择排序是一种不稳定的排序;
4.冒泡排序
算法思想:两两之间相互比较交换,达到排序目的;
代码实现;
void bubbleSort(int* a, int n)
{
for (int j = 0; j < n; j++)
{
bool flag = false;
for (int i = 1; i < n-j; i++)
{
if (a[i] < a[i - 1])
{
swap(&a[i - 1], &a[i]);
flag = true;
}
}
if (flag == false)
{
break;
}
}
}
时间复杂度:
最好:有序时,只需比较N-1次,O(N)
最坏:逆序时等差数列O(N2);
5.堆排序
堆是一种常见的数据结构——完全二叉树;
算法思想:排升序,建大堆
建堆方式:向上调整建堆(模拟插入过程);向下调整建堆;
堆排序
void HeapSort(int* a, int n)
{
//建堆;
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
//向下调整建堆;
/*for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}*/
//模拟删除过程排序;
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
向上建堆时间复杂度O(N*logN),向下调整时间复杂度O(N)
模拟删除过程排序时间复杂度O(N*logN);
堆排序时间复杂度O(N*logN);
堆排序是不稳定的;
6.快速排序
最牛逼的排序要不,要不然怎么叫快排呢;
算法思想,类似与数组划分,选出一个基准值,小于基准值的调到左边,大于基准值的调到右边;
实现方法有hoare版本,挖坑法,双指针法,三路划分法;
//快速排序 平均N*logn 最坏接近有序n的平方;
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;//只有一个值,或区间不存在则返回;
int keyi = PartSort3(a, left, right);
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}
//hoare版本
int PartSort1(int* a, int left, int right)
{
int begin = left, end = right;
int keyi = left;
while (left < right)
{ //右边找小;
while (left<right && a[left]>=a[keyi])
{
left++;
}
//左边找大
while (left < right && a[left] <= a[keyi])
{
right--;
}
//交换;
swap(&a[left], a[right]);
}
swap(&a[keyi], a[left]);
keyi = left;
return keyi;
}
//挖空法
int PartSort2(int* a, int left, int right)
{
int key = a[left];
int hole = left;
while (left < right)
{
// 右边找小
while (left < right && a[right] >= key)
--right;
a[hole] = a[right];
hole = right;
// 左边找大
while (left < right && a[left] <= key)
++left;
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
//前后指针法,数组划分;
int PartSort3(int* a, int left, int right)
{
int keyi = left;
int prev = left;
int cur = left + 1;
for (cur = left + 1; cur <= right; cur++)
{
if (a[cur] < a[keyi])
{
prev++;
swap(&a[prev], &a[cur]);
}
}
swap(&a[keyi], &a[prev]);
keyi = prev;
return keyi;
}
平均时间复杂度O(N*logN),最坏接近有序O(N的平方);
快速排序是一种不稳定的算法;
7.归并排序
分治的思想,选一个中间值,使它左区间有序,右区间有序,返回的时候合并两个有序数组;
代码实现:
class Solution {
public int[] sortArray(int[] nums) {
mergesort(nums,0,nums.length-1);
return nums;
}
public void mergesort(int[]nums,int left,int right)
{
if(left>=right)
{
return;
}
int mid=(left+right)/2;
mergesort(nums,left,mid);
mergesort(nums,mid+1,right);
int[]tmp=new int[right-left+1];
int i=0,cur1=left,cur2=mid+1;
while(cur1<=mid&&cur2<=right)
{
tmp[i++]=nums[cur1]<=nums[cur2]?nums[cur1++]:nums[cur2++];
}
while(cur1<=mid) tmp[i++]=nums[cur1++];
while(cur2<=mid) tmp[i++]=nums[cur2++];
for(int j=left;j<=right;j++)
{
nums[j]=tmp[j-left];
}
}
}
时间复杂度O(N*logN)
归并排序是一种稳定的排序;
8.总结;