简单介绍一下几种排序

1.冒泡排序

冒泡排序就是相邻两个元素比较，若arr[0]>arr[1]，则两个数进行值交换，把较大的数放到右边，第一趟排最大的数。然后第一趟结束后进行第二趟，第三趟，第四趟。

举个例子，给出一个长度为5的数组{6,3,7,14,10}，用冒泡排序法输出排序结果

 int[] arr = {6,3,7,14,10};
//        这一层控制循环多少趟
        for (int i = 0,t; i < arr.length-1; i++) {
//            这一层控制每一趟的循环次数
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]) {
                    t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
        for(int i:arr){
            System.out.print(i+"\t");
        }

运行结果如下：

2.选择排序

选择排序就是，先假定数组第一个arr[0]为最大值，最大值的位置为0。和第二个数arr[1]相比较，若最大值小于第二个数，则最大值位置是第二个数的下标。如果最大值位置不等于最大位置，则需要交换位置

依旧拿长度为5的数组{6,3,7,14,10}来举例

        int[] arr = {6, 3, 7, 14, 10};
        for (int i = 0, maxIx, maxValIx, t; i < arr.length - 1; i++) {
            maxValIx = 0;
            maxIx = arr.length - 1 - i;
            for (int j = 1; j <= arr.length - 1 - i; j++) {
                if (arr[maxValIx] < arr[j]) {
                    maxValIx = j;
                }
            }
            if (maxIx != maxValIx) {
                t = arr[maxIx];
                arr[maxIx] = arr[maxValIx];
                arr[maxValIx] = t;
            }
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }

运行结果如下：

3.插入排序

插入排序是从arr[1]开始，然后定义一个t,把arr[1]的值给t。再定义一个j，j取i-1。如果arr[j]>t，就会有值交换。交换完了之后，j需要自减1，所以需要把t的值给arr[j+1]。

int[] arr = {6,3,7,14,10};
//        从第二个数开始，并且把第二个数复制一份拿出来给t
        for (int i = 1,t,j; i < arr.length; i++) {
            t=arr[i];
//            j取i的前一位，且j对应的值大于t的值，交换位置
            for (j = i-1; j>=0 && arr[j]>t; j--) {
//            把前一个值挪到后面一个位置上
                arr[j+1]=arr[j];
            }
//            然后把t对应的值给（j-1+1）对应的值
            arr[j+1]=t;
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }

 运行结果如下：

4.希尔排序

希尔排序就是先使得数组相对有序，然后再用插入排序做一次排序。

以下例子是随机生成一个长度为20的数组，数组的值取1-100之间的数。代码中的step表示步数，若arr[i]>arr[i+step],则这两个数进行交换。这里的每一次step是之前step的二分之一。这里就是指的先相对有序。

Random rand = new Random();
        int[] arr = new int[20];
        int i;
        for (i = 0; i < arr.length; i++) {
            arr[i]=rand.nextInt(100)+1;
        }
        for (int i1 : arr) {
            System.out.print(i1+"\t");
        }
        System.out.println();
        int step = arr.length;
        while((step=step/2)>2){
            int t;
            for (i = 0; i+step < arr.length; i++) {
                if(arr[i]>arr[i+step]){
                    t=arr[step];
                    arr[step]=arr[i];
                    arr[i]=t;
                }
            }
        }
        for (int c : arr) {
            System.out.print(c+"\t");
        }
            System.out.println();
        for (int j = 1; j <arr.length ; j++) {
            int t=arr[j],k;
            for (k = j-1;k>=0 && arr[k]>t; k--) {
                arr[k+1]=arr[k];
            }
            arr[k+1]=t;
        }

        for (int i1 : arr) {
            System.out.print(i1+"\t");
        }

 运行结果如下：

第一行是原始数组，第二行是相对有序数组，第三行是在第二行相对有序上进行了插入排序得到的最终有序数组。

5.桶排序

经历两次排序，就可以得到最后排序结果。点我查看~这是桶排序具体例子的可视化图解

 举个例子：

 Random rand = new Random();
        int[] arr = new int[12];
        for (int i = 0; i <arr.length ; i++) {
            arr[i] = rand.nextInt(100)+1;
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }
        System.out.println();
//        设置一个常量U为10
        final int U = 10;
//        设置一个二维数组：桶。桶的数量为10个，每个桶的长度为一维数组arr的长度
        int[][] bucket = new int[U][arr.length];
//       设置一个一维数组：ixs。这是用来存放个位数为某数的arr数的数量。
        int[] ixs = new int[U];
        int t,count;
//       这里的i代表的是判定一维数组arr中的数为几位数
        for (int i = 1;; i*=10) {
            count = 0;
            for (int j = 0; j <arr.length ; j++) {
                count=(t=arr[j]/i)>=1?++count:count;
                bucket[t%=U][ixs[t]++]=arr[j];
            }
//            如果count为0，则表示没有最高位了。
            if (count==0)break;
//          把桶里面的元素依次取出，更新为arr[ix++]。
            for (int j = 0,ix=0; j <bucket.length; j++) {
                for (int k = 0; k <ixs[j]; k++) {
                    arr[ix++]=bucket[j][k];
                }
            }
            //把桶数组的每一列的行数清零。
            for (int j = 0; j <ixs.length; j++) {
                ixs[j]=0;
            }
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }

运行结果如下：

第一行为原始数组，第二行为桶排序后的数组。