java实现常见排序（选择，冒泡，插入，快速，希尔，堆）

选择排序

定义一个的标志位temp，默认为比较的第一个数的下标，分别与后面的数进行比较，若比比较的数字大，则把该数的下标赋给temp，循环一次结束后判断temp的值，若temp值跟第一个数的下标不一样，则把第一个数跟下标为temp的值交换，若temp值一样，则说明后面的数字都比第一个数大，则不交换，继续下一次循环，以此类推，直到循环结束，具体实现的代码如下：

public class Main {    public static void main(String[] args) {        int array[] = new int[]{2,4,6,8,1,3,5,7,10,9};        int index,current;        for(int i=0;i<array.length-1;i++){            index=i;            for(int j=i+1;j<array.length;j++){                if(array[index]>array[j]){                    index = j;                }            }            if(index!=i){                current = array[i];                array[i] = array[index];                array[index] = current;            }        }    }}

冒泡排序

冒泡排序，有一个口诀"大数沉底，小数往上飘"，可见，冒泡排序每一次找出的都是当前需要排列的数字中的最大的那个值，那样当所有的数都遍历过后，也就从小到大排好了序，具体实现如下：

public class Main {    public static void main(String[] args) {        int array[] = new int[]{2,4,6,8,1,3,5,7,10,9};        int temp;        for(int i=0;i<array.length;i++){            for (int j=0;j<array.length-1;j++){                if(array[j]>array[j+1]){                    temp = array[j];                    array[j] = array[j+1];                    array[j+1] = temp;                }            }        }    }}

插入排序

插入排序，可以简单理解为在打扑克，每次拿到一张新的牌子都会对手中的牌子做比较，找到对应该牌的位置后插入，那样在手中的牌子则一直是排好序的。具体到数组中的话，把数组第一位数当作手中的牌，后面的数则是要插入的数字，插入排序最坏的运行时间是O(n²)。具体代码实现如下：

public class Main {    public static void main(String[] args) {        int array[] = new int[]{2,4,6,8,1,3,5,7,10,9};        int current,temp;        //除去第一个数，后面均是要插入的数        for(int i=1;i<array.length;i++){            current = array[i]; //要插入的数            temp = i; //记录插入数的位置            for(int j=i-1;j>=0;j--){                if(array[j]>current){                    array[j+1] = array[j];                    temp --;                }            }            array[temp] = current;        }    }}

快速排序

快速排序采用了"二分"的思维。选用一个数作为基数（一般是数组中的第一个数），从右往左找小于基数的数i，从左到右找大于基数的数j，若i!=j，则交换两个数，若i==j，则退出当前循环，且array[i]与基数进行交换。这样通过基数就形成了两个区间，再重复以上操作，直到区间只剩下一个数字为止，最终实现小的数在基数的左边，大的数在基数的右边。具体实现代码如下：

public class Main {    public static void main(String[] args) {        int array[] = new int[]{2,4,6,8,1,3,5,7,10,9};        quickSort(array,0,array.length-1);        for (int i=0;i<array.length;i++){            System.out.print(array[i]+" ");        }    }    public static void quickSort(int[] array,int low,int high){        if(low<high){            int middle = sortUtil(array,low,high);            //左边排序            quickSort(array,low,middle-1);            //右边排序            quickSort(array,middle+1,high);        }    }    public static int sortUtil(int[] array,int low,int high){        int temp = array[low];        while(low<high){            //找到比temp要小的值，交换            while (low<high && array[high]>temp){                high--;            }            array[low] = array[high];            //找到比temp要大的值，交换            while (low<high && array[low]<temp){                low++;            }            array[high] = array[low];        }        array[low] = temp;        return low;    }}

希尔排序

希尔排序沿用了插入排序的原理，同时也有"二分法"的思想在里面。先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。其中，以增量d一般为待排序的序列长度的一半。

public class Main {    public static void main(String[] args) {        int array[] = new int[]{2,4,6,8,1,3,5,7,10,9};        int j,temp;        for (int length=array.length/2; length>0; length/= 2) {            for (int i=length; i<array.length; i++) {                temp=array[i];                for (j=i-length;j>= 0;j-=length) {                    if (temp<array[j]) {                        array[j+length]=array[j];                    } else {                        break;                    }                }                array[j + length] = temp;            }        }    }}

堆排序

堆排序的基本思想是将待排序的序列构造成一个大顶堆（从上往下，从左往右数字逐渐减小）。此时，整个序列的最大值就是堆顶的根节点。将它与堆数组的末尾元素交换，此时末尾元素就是最大值，然后将除去末尾元素的剩余的 n-1 个序列重新构造成一个堆，这样就会得到 n 个元素中次大的值。如此反复执行，便能得到一个有序序列了。 

public class Main {    public static void main(String[] args) {        int array[] = {2,4,6,8,1,3,5,7,10,9};        int i,temp;        for (i = array.length / 2 - 1; i >= 0; i--) {            // 构建一个大顶堆            adjust(array, i, array.length - 1);        }        for (i = array.length - 1; i >= 0; i--) {            // 将堆顶记录和当前未经排序子序列的最后一个记录交换            temp = array[0];            array[0] = array[i];            array[i] = temp;            // 将array中前i-1个记录重新调整为大顶堆            adjust(array, 0, i - 1);        }    }    public static void adjust(int[] array, int i, int len) {        int temp,j;        temp = array[i];        for (j = 2 * i; j < len; j *= 2) {            if (j < len && array[j] < array[j + 1]){                ++j;            }            if (temp >= array[j]){                break;            }            array[i] = array[j];            i = j;        }        array[i] = temp;    }}