Java实现常见的7种排序算法

主要总结一下以下常见的排序以及其java的实现，包含有：

比较排序

冒泡排序

插入排序

希尔排序

快速排序

堆排序

归并排序

1.比较排序：从第0个开始分别与后面的比较，正序不交换，反序就交换。时间复杂度n+(n-1)+.....1=（1+n）n/2=O(n^2)。

/**比较排序 * 2015年10月29日上午9:53:38 * @param data */public static void CompareSort(int[] data){for(int i=0;i<data.length;i++){for(int j=i+1;j<data.length;j++){if(data[i]>data[j]){int change=data[i];data[i]=data[j];data[j]=change;}}}}

2.冒泡排序：最后一个开始 a[n]与a[n-1]比较，正序不交换，反序交换，接着比较a[n-1]与a[n-2] ....遍历一遍可以最小的排到最上面，如此遍历n遍就可以实现排序，从底到上，如冒泡一样。时间复杂度为O(n^2)

/** * 冒泡排序 2015年10月29日上午9:53:38 *  * @param data */public static void bubleSort(int[] data) {for (int i = 1; i <= data.length; i++) {for (int j1 = data.length - 1, j2 = j1 - 1; j2 >= 0; j2--, j1--) {if (data[j1] < data[j2]) {int change = data[j1];data[j1] = data[j2];data[j2] = change;}}}}

   改进：去掉已经排序了的部分

/** * 冒泡排序 2015年10月29日上午9:53:38 *  * @param data */public static void bubleSort(int[] data) {for (int i = 0; i <data.length; i++) {for (int j1 = data.length - 1, j2 = j1 - 1; j2 >i; j2--, j1--) {if (data[j1] < data[j2]) {int change = data[j1];data[j1] = data[j2];data[j2] = change;}}}}

     进一步改进：假如已经没有可以比较的了，退出循环

/** * 冒泡排序 2015年10月29日上午9:53:38 *  * @param data */public static void bubleSort(int[] data) {        Boolean noFinishCompare=true;for (int i = 0; i <data.length&&noFinishCompare; i++) {                noFinishCompare=false;for (int j1 = data.length - 1, j2 = j1 - 1; j2 >i; j2--, j1--) {if (data[j1] < data[j2]) {int change = data[j1];data[j1] = data[j2];data[j2] = change;noFinishCompare=true;//只要有交换就没有完成比较}}}}

3.插入排序：将要排序的数组分成两个部分，一部分是已经排序好了，一部分是原来的，一开始默认已经排序好的只有第一个数组下标。接着从第二个数组开始遍历，判断要排序的元素在已经排序的部分的位置，然后插入。比如判断第二个数组比第一个数组小，插入在左边，比它大插入在右边，确定插入位置的依据是比上一个位置小，不大于下一个位置。时间复杂度为O(n^2);

/**插入排序 * 2015年10月29日上午11:09:33 * @param data */public static void inSertSort(int[] data ){for(int i=1;i<data.length;i++){if(data[i]<data[0]){int change=data[i];//拿出data[i]for(int s=i;s>=1;s--)//从0位起将i前面的后移一位{data[s]=data[s-1];}data[0]=change;//将i放到第一位}if(data[i]>data[0]){int change=data[i];//拿出data[i]for(int s=0;s<i;s++ )//遍历已经排序的部分{  if(change>data[s]&&change<=data[s+1]){//通过大于【i】小于或等于【i+1】来确定要插入的位置                                    for(int e=i;e>=s+1;e--){data[e]=data[e-1];  //右移动留出插入位置}data[s+1]=change;  //插入}}}}}

改进：由于前部分已经排序了的，那么判断a[i]的插入位置可以根据往前推算判断，若a[i-1]>a[i],那么a[i-1]后移以一位，知道a[i-k]<a[i],那么i-k之前的数肯定比i的小，可以将a[i]插入到a[i-k+1]的位置上：

/**插入排序 * 2015年10月29日上午11:09:33 * @param data */public static void inSertSort(int[] data ){for(int i=1;i<data.length;i++){int ai=data[i];int j;for(j=i-1;j>=0&&data[j]>ai;j--){data[j+1]=data[j];}data[j+1]=ai;}}

4.希尔排序：

原理是什么：对于无序数组 a【1】a【2】a【3】a【4】a【5】a【6】

将其划分成子序列： gap=6/2=3;

分别是 ：  a【1】a【4】       a【2】a【5】       a【5】a【6】 正序不交换，反序交换

那么通过排序让子序列有序得到：b【1】b【2】b【3】b【4】b【5】b【6】
 可知：b【1】<b【4】  b【2】<b【5】   b【3】<b【6】

接下来 gap=3/2=1;

分别是：b【1】b【2】     b【2】b【3 】  b【3】b【4】     b【4】b【5】    b【5】b【6】

排序后得到序列：c【1】c【2】c【3】c【4】c【5】c【6】

可知c【1】<c【2】  c【2】<c【3】   】 c【3】<c【4】   c【4】<c【5】   c【5】<c【6】

结合b,可得到有序序列。

算法核心：不断的分成几个有序子序列，对子序列进行排序，最后得到基本有序的序列，然后进行一次插入排序。

public static void ShellSort(int[] datas){int gap=datas.length/2;if(datas.length>0)gap=datas.length%2==0?gap-1:gap;while(gap>=1){for(int i=0;i<=datas.length/2;i++){if(datas[i]>datas[i+gap]){int exchange=datas[i+gap];datas[i+gap]=datas[i];datas[i]=exchange;}}gap=gap/2;}inSertSort(datas);}}

希尔排序最终也是用到插入排序，目的就是尽可以有序化，减小插入排序的运算，定义一个变量用于确定它允许的次数：

/**插入排序 * 2015年10月29日上午11:09:33 * @param data */public static void inSertSort(int[] data ){for(int i=1;i<data.length;i++){int ai=data[i];int j;for(j=i-1;j>=0&&data[j]>ai;j--){System.out.println("-----num"+num++);data[j+1]=data[j];}data[j+1]=ai;}}public static void ShellSort(int[] datas){int gap=datas.length/3;if(datas.length>0)gap=datas.length%2==0?gap-1:gap;while(gap>=1){for(int i=0;i<=datas.length/2;i++){if(datas[i]>datas[i+gap]){System.out.println("-----num"+num++);int exchange=datas[i+gap];datas[i+gap]=datas[i];datas[i]=exchange;}}gap=gap/3;}inSertSort(datas);}

测试数据如下：

int[] datas = new int[] {8,15,4,55,98,14,77,35,88,21,546,875,1,65,756,43,4,87,54,11,25,66,78,95,555,423,657,442};

但是调用插入排序，打印出来的num:

-----num125

使用希尔排序的话：

-----num65

而且希尔排序的步长不一样的话运算树也不一样：

public static void ShellSort(int[] datas){int gap=datas.length/3;if(datas.length>0)gap=datas.length%2==0?gap-1:gap;while(gap>=1){for(int i=0;i<=datas.length/2;i++){if(datas[i]>datas[i+gap]){System.out.println("-----num"+num++);int exchange=datas[i+gap];datas[i+gap]=datas[i];datas[i]=exchange;}}gap=gap/2;}inSertSort(datas);}

打印出来的是：

-----num61

5.快速排序：

快速排序也叫分治法，以一个基准数为标准将其分为两个部分，一个是比这个数小的部分，一个是比这个数大的部分，然后让这两个部分按照这样的法则递归下去。

分成两个有序的部分思想是：

【1】【2】【3】【4】....【k】...【n-1】【n】

先以key=【1】为基准数，从n下标往左遍历，获取到第一个比key小的【k】,交换位置:【k】【2】【3】..【m】.....【1】.。。【n-1】【n】

然后从2开始往左遍历，找到第一个比key大的【m】,交换k下标以2下标：【k】【2】【3】..【1】..【m】...【n-1】【n】

可以知道：【1】前面的数都比【1】小，【m】后面的数都比【m】大

然后继续按照这个法则，从【1】下标到【m】的下标进行排序，一直到左边的下标等于右边的下标，最终分成两个部分....【1】....

前面的比【1】小，后面的比【1】大。。

然后分成两个部分递归，从0下标到【1】前一个下标，从【1】的后一个下标到【n】下标。以此下去最终通过实现排序。

/**快速排序 * 2015年10月30日下午1:50:53 *  * @param data */public static void FastSortToHalf(int[] data, int leftFirstPosition,int rightLastPosition) {int size = rightLastPosition;if (leftFirstPosition < rightLastPosition) {while (leftFirstPosition < rightLastPosition) {//通过循环分成两个部分int key = data[leftFirstPosition];while (rightLastPosition > leftFirstPosition&& data[rightLastPosition] >= key) {rightLastPosition--;}if (leftFirstPosition < rightLastPosition) {data[leftFirstPosition] = data[rightLastPosition];data[rightLastPosition] = key;}while (leftFirstPosition < rightLastPosition&& data[leftFirstPosition] <= key) {leftFirstPosition++;}if (leftFirstPosition < rightLastPosition) {int changge = data[leftFirstPosition];data[leftFirstPosition] = data[rightLastPosition];data[rightLastPosition] = changge;}}FastSortToHalf(data, 0, leftFirstPosition - 1);//对这两个部分进行递归FastSortToHalf(data, leftFirstPosition + 1, size);}}

6.堆排序：

堆排序最好最坏以及平均的情况下时间复杂度都是O(nlongn),性能上比比较排序、冒泡排序、插入排序好。

思想：需要构建与保持一个最大堆，然后利用最大堆的性质实现排序。

原理：将要排序的数组看成一个完全二叉树，对于第i个位置，如果他有parent，那么parent位置为i/2,如果他有左子树，那么左子树位置为2*i,如果他有右子树，那么右子树位置为2*i+1,构建最大堆的原理是：如果父节点比它的子节点小，那么将父节点与它子节点的最大节点交换，子节点以此类推，达到父节点永远大于子节点，如此从下往上递归，最终根节点是最大的数。创建了大项堆后，将更节点的值与最后的值交换，将0-n-1下标的项重新构造大项堆，如此递归下去，最终排序。

所以步骤有：1.构造大项堆 2.将根节点与最后项交换 3.递归。

public static void HeapSort(int[] data) {        BuildBiggestHeap(data, data.length);//创建大项堆        for(int i=data.length;i>2;i--)//最后一个长度应该是3个节点        {          swap(data, 0,i-1);//交换根节点与最后项        BuildBiggestHeap(data, i);//重新创建大项堆        }}/**创建大项堆 * 2015年11月2日下午3:21:02 * @param data * @param length */public static void BuildBiggestHeap(int[] data,int length) {if(length>data.length)return;for(int i=length/2-1;i>=0;i--){int parent_position=i;int left_position=i*2+1;int right_position=i*2+2;if(right_position<length){if(right_position==length-1){//这时只有一个左子节点if(data[parent_position]<data[left_position]);swap(data, left_position, parent_position);}else{//有两个子节点int lagerposition=0;lagerposition=data[left_position]>data[right_position]?left_position:right_position;lagerposition=data[lagerposition]>data[parent_position]?lagerposition:parent_position;if(lagerposition!=parent_position)swap(data, parent_position, lagerposition);}}}}     //交换    private static void swap(int[] data, int i, int j) {           int tmp=data[i];           data[i]=data[j];           data[j]=tmp;       } 

7.归并排序：

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

排序实现思路是：将数组分成左右两个部分，将两个部分分别进行排序，然后将排序了的两个部分合并。

拆分的思路是通过递归进行不断的拆分，最终拆分成长度为2或者3的序列。

归并的思路是：构造一个缓冲数组，数组长度为要归并的两部分的长度，左部分下标为i,右部分下标为j，数组下标为k，如果a【i】<a【j】,那么将a【i】赋予s【k】，并i++,k++，反之j++,k++。当i或者j长度分配完后,应该讲i或者j剩下的部分按顺序富裕k。

所以代码实现的步骤为：1.拆分.  2.合并   并且对拆分进行递归。

<strong> </strong>private static void MergeSort(int[] data,int firstposition,int mergeiength)    {    if(mergeiength==2)    {    sortlength2(data,firstposition);//长度为2时排序    return;    }    if(mergeiength==3){    sortlength3(data,firstposition);//长度为3时排序    return;    }                    int mergeleftlength=mergeiength/2;    int mergerightlength=mergeiength-mergeleftlength;        MergeSort(data, firstposition, mergeleftlength);//拆分左边进行递归    MergeSort(data, firstposition+mergeleftlength, mergerightlength);//拆分右边进行递归        //拆分排序后将左右两部分合并    int[] temp=new int[mergeiength];//缓存数组，将左右部分合并到缓存数组中    int tempposition=0;        int i=firstposition,j=i+mergeleftlength;    int leftmaxposition=firstposition+mergeleftlength;    int rightmaxposition=firstposition+mergeiength;    while(i<leftmaxposition&&j<rightmaxposition){        if(data[i]>data[j])     {    temp[tempposition++]=data[j++];         }else {     temp[tempposition++]=data[i++];     }        }     while(tempposition<mergeiength)//合并剩余的部分     {     if(i<leftmaxposition)     {     temp[tempposition++]=data[i++];     }     if(j<rightmaxposition){     temp[tempposition++]=data[j++];     }     }            System.arraycopy(temp, 0, data, firstposition, mergeiength);//拷贝到缓存数组的对应位置中    }            private static void sortlength3(int[] data, int firstposition) {sortlength2(data, firstposition);//先排好前两个if(data[firstposition+2]<data[firstposition]){int s=data[firstposition+2]; data[firstposition+2]=data[firstposition+1]; data[firstposition+1]=data[firstposition]; data[firstposition]=s;}if(data[firstposition+2]>data[firstposition]&&data[firstposition+2]<data[firstposition+1]){int s=data[firstposition+2]; data[firstposition+2]=data[firstposition+1]; data[firstposition+1]=s;}}private static void sortlength2(int[] data, int firstposition) {if(data[firstposition]>data[firstposition+1])swap(data, firstposition, firstposition+1);}