java Sorting Algorithm Summary (bubble, select, insert, bucket sort row fast)

This article is a summary of some of the common sorting algorithm, it will be continuously updated. Code written more you know, the more important the more basic things, only to master the most basic sorting algorithm in order in the face of practical problems, flexible and cleverly solved. A summary of every sort I have written in comments in the code, and the code is:

[Imprint] please indicate the source (please respect the original, bloggers reserved the right to pursue)
http://blog.csdn.net/qq_24295537/article/details/78025375
by [the blog] yangLiHai_

/**
 * 公共的交换元素方法
 */
public static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
}


/**
 * 冒泡排序
 * 冒泡排序是一种最简单的排序算法，说简单是理解起来简单。通过内循环每次比较两个相邻的元素
 * 内循环结束后，拿出一个最值放在末尾，然后通过外循环再次执行，得到第二个最值。外循环要-1，
 * 因为没必要对最后一个元素进行排序。同理，内循环也要-1，同时要-i，因为i后边的几位已经排好序了。
 * @param arr
 */
public static void bubbleSort(int[] arr){
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-i-1; j++) {
            if (arr[j]>arr[j+1]) {
                swap(arr, j, j+1);
            }
        }
    }
}


/**
 * 选择排序
 * 选择排序和冒泡排序很类似，理解难度都一样。同样是两个for循环，外循环需要-1，道理等同于上边的冒泡排序，
 * 内循环第一次比较的是相邻的两个元素，拿出比较的结果放在左边，然后和相邻的元素的下一个元素比较，比较结果同样放在左边，
 * 循环结束后，最左侧的元素放置的就是这个最值，然后通过外循环再次进入下一轮内循环，结束后得到第二个最值放在左边。
 * 选择排序和冒泡排序的不同是：
 * 1.冒泡排序每次内循环都是比较相邻的两个元素，而选择排序会跨越多个元素比较，
 * 2.选择排序每一次比较的值放在左边，冒泡排序每一次比较的值放在右边，
 * 相同的是他们的效率都一样低（cry）
 * @param arr
 */
public static void selectSort(int[] arr){
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = i+1; j < arr.length; j++) {
            if (arr[i]>arr[j]) {
                swap(arr, i, j);
            }
        }
    }
}

/**
 * 插入排序
 * 插入排序的起始位置并不是第一个，而是第二个，所以i=1，i之前的元素可以被认为是已经排好序的。
 * 每一次for循环遍历都是拿i元素去和第i-1个元素进行比较，如果比i-1还小，那么第i-1个元素向后移动一位到i，
 * 再拿i元素和第i-2个元素比较，同样执行以上操作，重复执行几次之后，直到找到排好序的元素小于等于i元素的位置，
 * 然后把元素赋值给此位置，然后继续执行下一次for循环
 * @param arr
 */
public static void insectionSort(int[] arr){
    for (int i = 1; i < arr.length; i++) {
        if (arr[i-1]>arr[i]) {
            int temp = arr[i];
            int j = i;
            while (j>0 && arr[j-1]>temp) {
                arr[j] = arr[j-1];
                j--;
            }
            arr[j] = temp;
        }
    }
}

/**
     * 快速排序是排序里边效率最高的的一种，只有shell排序能和他媲美。个人认为是比较难理解，
     * 我也是三番五次才完全理解透彻。需要三个参数，除了数组arr以外，还需要传入数组第一个参数的下标，和最有一个下标。
     * 总体思想：先找一个key,作为参照物，然后拿分别拿两端的数据去和key比较，根据比较结果进行交换，一轮交换后key的位置确定下来，
     * 并且key左侧的值都比key小，右侧的值都比key大，然后用同样的方法对key两侧的值进行排序。
     * 第一步：记录在方法内记录下标的副本，就是ｉ和ｊ，同时记录第一个下标的值为key，key就是我们所说的参照物。
     * 第二步：首先拿arr[j]和key比较，如果比key大，则j--,然后拿arr[i]和key比较，如果比key小，则i++。
     * 第三步：两个while循环执行结束之后，arr[j]<key,arr[i]>key,则交换i,j的数据，交换之后，arr[j]>key,arr[i]<key.
     * 第四步：重新执行第二步，直至i=j,这个时候把arr[left](也就是key)和arr[j]，交换之后arr[j]左边的数据都比key小，
     * 右边的数据都比key大，执行到这一步，我们的思路基本就清晰了。
     * 第五步：用递归的思维方式，对arr[j]左边的和右边的数据分别排序，递归完成之后，我们就得到一个有序的数组。
     * 注意事项：一定要先从ｊ开始进行while循环，因为j停止的时候找到的是比key小的位置，最终i和j相遇后所在的位置需要和arr[left]交换的，
     * 如果先从i开始while循环，那么最终i和j相遇后所在的位置一定会比arr[left]大，如果和arr[left]交换后就不会得到效果。
     * @param arr
     * @param left
     * @param right
     */
public static void quickSort(int[] arr,int left, int right) {
    if (left>right) return;
    int i = left;
    int j = right;
    int key = arr[i];
    while(i!=j) {
        while(j>i && arr[j]>=key) {
            j--;
        }
        while(j>i && arr[i]<=key) {
            i++;
        }
        if (j>i) {
            swap(arr, i, j);
        }
    }

    arr[left] = arr[j];
    arr[j] = key;

    quickSort(arr, left, i-1);
    quickSort(arr, i+1, right);
}

/**
*桶排序
*/
public static void bucketSort(int[] arr,int maxlength) {
        for (int i = 0; i < maxlength; i++) {
            int[][] tempData = new int[10][arr.length];
            int index[] = new int[10];
            Arrays.fill(index, 0);
            int pider = (int)Math.pow(10, i);
            for (int j = 0; j < arr.length; j++) {
                int temp = arr[j] ;
                int key = temp / pider % 10;
                tempData[key][index[key]] = arr[j];
                index[key]++;
            }

            int conter=0;
            for (int j = 0; j < tempData.length; j++) {
                for (int z  = 0; z < index[j]; z++) {
                    arr[conter] = tempData[j][z];
                    conter++;
                }
            }
        }
        return ;
    }