常见的几种排序算法（java和C++版）（参考《算法》）

1. 博主这里要讲的几种排序算法包括（从难到易）：

1.冒泡排序（最low的算法）

2.插入排序

3.希尔排序

4.归并排序

5.快速排序

6.快速排序的三项切分

冒泡排序：

（1）简介：这是最原始，最简单的排序，几乎不需要额外的空间

（2）基本原理：通过循环将最大的元素移到最末端或者最前端，俗称冒泡！

（3）时间复杂度：O（n^2）

（4）空间复杂度：O（n）

（5）代码： 

         C++版：

void sort1(int *A,int maxx)                //这里的冒泡是让较小的数往前冒{    while(maxx--){              //总共有maxx个元素，故循环maxx次，但是实际上值执行了maxx-1次，细心的小伙伴也许注意到了，因为当//执行完maxx-1次的时候，数组已经排好了序        int j=maxx;        while(j>=0 &&j--){            if(A[j]>A[maxx]) //如果前面的元素比A[maxx]大，则交换两元素，就是说将小的值前移                exch(A,maxx,j);        }    }}

void exch(int *A,int a,int b)        //交换数组的两元素{    int t=A[a];    A[a]=A[b];A[b]=t;}

         Java版：

public static void sort1(Comparable[] a,int max,boolean options){//排序1：最low的算法：冒泡排序int N=a.length;for(int i=0;i<N;i++){    //其实冒泡排序是这样执行的：A[0]是0到a.length中最小的元素，而后不管A[0],A[1]就是1到a.length中最小的元素，

int min=i; //故每次找最小的元素既可for(int j=i+1;j<N;j++){if(less(a[j],a[min]))min=j;//如果a[j]比a[min]小，则交换j和min}exch(a,i,min);}}

 public static void exch(Comparable[] a,int i,int j){      //交换a[i],a[j]  Comparable t=a[i];a[i]=a[j];a[j]=t; }

 public static boolean less(Comparable a,Comparable b){      //a是否比b小  return a.compareTo(b)<0; }

（6）优点：无

插入排序：

（1）简介：还是比较简单的排序算法，有的时候比其他算法更快（反正肯定比冒泡快），算法的快慢取决于处理的数据，后面会讲

（2）基本原理：先将A[0]看成一个数组，然后A[i]逐渐加入该数组，每加入一个元素就对该数组排序，就是说如果新添的元素比前面的小，那么该元素的位置前移，比它大的元素全部后移一位，博主此处的代码在比较的同时顺便移动元素的位置，优化了代码！

（3）时间复杂度：最坏：O（n^2）

                               最好：O（n）

（4）空间复杂度：           O（n）

（5）代码：

         C++版：

void sort2(int *A,int maxx)//插入排序,一般的插入排序是要交换两数组的值，这里我们优化一下操作，使他不需要交换数组元素，也能达到移动数组的目的{    int now,j,i;           //初始化now元素    for(i=1;i<maxx;i++){   //循环maxx-1次，相当于A[0]已经排好了，现在从A[1]开始往里增长序列，的每一个新增的元素都找到自己的位置，如果新加的元素        for(now=A[i],j=i-1;j>=0 && now<A[j];j--){    //比前面的元素小，那么前面的元素要腾出位置给它，            A[j+1]=A[j];                             //并且保证该位置前面一个元素要比它小，后面的元素不小于它，其实就是找出合适的位置        }        A[j+1]=now;    }}

         Java版：

public static void sort2(Comparable[] a,int lo,int hi,int max){  //插入排序,这里的lo和hi是指数组的初下标和末下标，大家先默认为0和a.lengthfor(int i=lo+1;i<=hi;i++){                                //后面会讲我这么做的原因，max其实没有意义，只是为了后面的接口一致if(less(a[i],a[i-1])){  //初步判断，其实有没有都可以int j=i-1;Comparable now=a[i];while(j>=lo && less(now,a[j])){//和C++的步骤相同a[j+1]=a[j];j--;}a[j+1]=now;}}}

 public static boolean less(Comparable a,Comparable b){      //a是否比b小  return a.compareTo(b)<0; }

（6）优点：处理小规模数组排序较快

希尔排序：

void shellSort(){int increment;//记录增量的变量int start;//记录每次插入排序的起始元素位置int temp;increment = count;//printf("IM HERE  %d",increment/3);for (increment = increment / 2; increment > 0; increment = increment / 2){//printf("IM HERE1");for (start = increment; start < count; start++){for (int j = start - increment; j >= 0 && data[j] > data[j + increment]; j -= increment){std::swap(data[j], data[j + increment]);}}}}

归并排序

快速排序

void quickSort(int low, int high){if (low > high)return;int i, j;int pivot;pivot = data[low];i = low;j = high;while (i != j){while (data[j] >= pivot&&i < j)j--;while (data[i] <= pivot&&i < j)i++;if (i < j)std::swap(data[i], data[j]);}data[low] = data[i];data[i] = pivot;/*for (int u = 0; u < count; u++)printf("%d ", data[u]);printf("\n");*/quickSort(low, i - 1);quickSort(i + 1, high);}