Java基础——冒泡、选择、插入、希尔、桶排序

冒泡排序：两两交换，交换完最大的值跑到了最后面，所以内层循环遍历的范围要减掉已经放置最大值的地方。

        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 c : arr) {
            System.out.println(c);
        }`

选择排序：假设第一个最大值，从第二位开始（内层循环从i+1开始），遍历数组，比较后找到最大值，更新最大值的索引，最后把最大值放在本轮循环最后的位置（最大值已经在最后面了，所以内层循环每轮都要减一，也就是减i）。（选择排序也可以先找出最小值放在前面，假设第一个是最小值，从i开始遍历，找到最小的值，然后更新最小值索引，交换最小值和第一位的位置（最小值在第一位后，内层循环就要从i开始了））

        int[] arr = new int[]{54,4,75,6,21,9,5,7,44,22};
        for (int i = 0,t; i <arr.length-1 ; i++) {
            int maxValIx=0;
            int 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 c : arr) {
            System.out.println(c);
        }

插入排序：拿出arr[i]赋值给t，j在i前面一位，比较arr[j]和t（arr[i]）的值，若arr[j]大，往后挪，遇到小的不挪，把t插进去

        int [] arr = new int[]{14,12,13,64,5,6,57,8,91,10};
        for (int i = 0,t,j; i <arr.length ; i++) {
            t=arr[i];
            for ( j = i-1; j>=0&&arr[j]>t; j--) {
                arr[j+1]=arr[j];
            }
            arr[j+1]=t;
        }
        for (int c : arr) {
            System.out.println(c);
        }

希尔排序：希尔增量是arr.length/2，希尔增量不断缩减，构成第一个循环；第二个循环从第二个希尔区间的开头算起，一直跑到结尾；第三个循环是在for里面依次对比第二个希尔区间值和第一个希尔区间值的大小，若前一个更大，则执行循环里两个值交换代码。

        int [] arr = new int[]{14,112,13,64,15,6,57,1,8,91,10};
        int N=arr.length,t;
        for (int h = N/2; h >0 ; h/=2) {
            for (int i = h; i <N ; i++) {
                for (int j = i; j>=h&&arr[j] <arr[j-h] ; j=j-h) {
                    t=arr[j];
                    arr[j]=arr[j-h];
                    arr[j-h]=t;
                }
            }
        }
        for (int c : arr) {
            System.out.println(c);
        }

桶排序：原理很简单，先拿出一组数组的个位数比较，若个位数相同，则依次存在其对应的数列（个位数对应的值）里，然后按照个位数的顺序依次把所有元素放回数组里。然后再比较十位数，百位数，等等，以此类推。代码如下：

        int [] arr = new int[]{14,12,13,64,5,6,57,8,91,10};
        int [] arr = new int[]{14,12,13,64,5,6,57,8,91,10};
        final int U=10;//10是基本单位，定义常量
        int[][] bucket = new int[U][arr.length];//二维数组
        int[] ixs = new int[U];//10位的数组
        for (int i = 1,t;; i*=10) {//一开始不知道数组里最大元素是几位数循环多少次，需要做个判断
            int count=0;
            for (int j = 0; j <arr.length ; j++) {
                t=arr[j]/i;//取整，取前面的
                if (t>=1){
                    ++count;
                }//上面四行可以用逻辑运算符写成count = (t=arr[j]/i)>=1?++count:count;
                t=t%U;//取余，取末位
                bucket[t][ixs[t]++]=arr[j];//把元素放进对应的二维数组里，行是0-9，列是取余后的值
            }
            if (count==0) break;//判断出最大位数后，即终止循环，循环结束
            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 c : arr) {
            System.out.print(c+"\t");
        }