各种排序算法

package com.amazonaws.mws.test;

import java.util.Arrays;

public class SortTest {

    public static void main(String[] ss) {

        int[] arr = {9, 2, 8, 6, 5, 4, 7, 1, 5, 8, 2, 6, 4, 1,};
        System.out.println(Arrays.toString(arr));
        baseSort(arr);
        System.out.println(Arrays.toString(arr));

    }


    /**
     * 基数排序
     * 此种方法是：通过对个位、十位、百位。。。的依次比较排序，然后决定最终排序
     * @param arr 排序的数组
     */
    private static void baseSort(int [] arr){
        int[][] ints = new int[10][arr.length];
        int[] ab = new int[10];
        int maxElement = Integer.MIN_VALUE;
        for (int i2 : arr) {
            if (i2 > maxElement)
                maxElement = i2;
        }
        int time = String.valueOf(maxElement).length();
        int index;

        for(int i = 0; i < time; i ++){
            for (int i1 : arr) {
                int ind = i1 / (i + 1) % 10;
                ints[ind][ab[ind]] = i1;
                ab[ind]++;
            }
            index = 0;
            for(int k = 0;k<ab.length;k++){
                if(ab[k] > 0){
                    for(int l = 0;l < ab[k];l++){
                        arr[index] = ints[k][l];
                        index ++;
                    }
                    ab[k] = 0;
                }
            }
        }
    }

    /**
     * 使用归并排序
     * 如果我们要对两个已经排好序的数组进行合并，并且要求合并后的依然是排序的。
     * 以上要求可以如此考虑，我们先创建一个等于两个数组长度之和的新数组，依次将两个数组从低位进行比较，将比较小的那个数据插入新的数组，知道某一个数组为空（或者全部插入）
     * 再将另一个数组剩余部分补位到新数组后面。这样两个数组的重新排序就完成了。
     * 当我们拿到一个乱序数组的时候，将数组不断细分，当分隔到每一个部分只有一个元素的时候，该子数组一定有序（只有一个元素），再将这些子数组依次合并排序，直到最后的数组完成排序.
     *
     * @param arr   传入数组
     * @param start 需要排序的初始位置
     * @param end   需要排序的结束位置
     * @return 排序后的数组
     */
    private static int[] mergeSort(int[] arr, int start, int end) {
        if (start >= end)
            return new int[]{arr[start]};

        int mid = (start + end) / 2;

        int[] leftArr = mergeSort(arr, start, mid);
        int[] rightArr = mergeSort(arr, mid + 1, end);
        int[] newArr = new int[leftArr.length + rightArr.length];
        int l = 0;
        int r = 0;
        int n = 0;
        while (l < leftArr.length && r < rightArr.length) {
            newArr[n++] = leftArr[l] < rightArr[r] ? leftArr[l++] : rightArr[r++];
        }
        while (l < leftArr.length){
            newArr[n++] = leftArr[l++];
        }
        while (r < rightArr.length){
            newArr[n++] = rightArr[r++];
        }
        return newArr;
    }


    /**
     * 选择排序:定义一个最小数据所在下标的 变量。
     * 先拿到数组最前列的数据，认为该数据就是最小数据，将其下标记录到上述变量中，然后使用该下标中的值依次向后比较，当碰到值比其小的，就将下标替换成新值的下标。
     * 当第一次比较过后，上述下标变量一定指向最小的元素的下标，将该下标上的值与第一个位置互换。
     * 之后认为第二个下标是剩下数据最小值，重复上述过程
     *
     * @param arr 排序数组
     */
    private static void choiceSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            int temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }


    /**
     * 希尔排序是以跨度分组的方式多次使用插入排序，下面代码中里面的两个for循环，如果当 的d = 1的时候，就是一个标准的插入排序了。
     * 希尔排序是在插入排序上进行改进得到的，一个长度为 n 的数组，下标 n-1 出是最小值，该值移动到下标 0  处，
     * 普通的插入排序需要比较 n-1 次，
     * 希尔排序在进行最后一次排序前，会将这个值先排到前列，使得其比较移动的次数变少了。
     *
     * @param arr 排序数组
     */
    private static void shellSort(int[] arr) {
        for (int d = arr.length / 2; d > 0; d /= 2) {
            for (int i = d; i < arr.length; i += d) {   //此处如果d为1 ，那么就类似一个插入排序算法
                for (int j = i; j > 0; j -= d) {
                    if (arr[j - d] > arr[j]) {
                        int temp = arr[j - d];
                        arr[j - d] = arr[j];
                        arr[j] = temp;
                    } else {
                        break;
                    }
                }
            }
        }
    }


    /**
     * 插入排序，思想是从数组中选取一个下标位置，我们认为这个位置之前的数据全部是正序的，
     * 我们只需要将这个位置的元素与前面的序列进行比较，将其插入到合适的位置即可
     * 因为前面是正序的，那么从插入位置开始（包含插入位置）的元素依次向后挪动一个位置。
     * 为了保证前面的元素都是正序的，我们从下标1开始进行比较
     *
     * @param arr 排序的数组
     */
    private static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {  //0下标位置的元素不用选取比较
            for (int j = i; j > 0; j--) {
                if (arr[j - 1] > arr[j]) {      //此处还可以不用每次交换，使用两个变量记录被选择位置的值和最后比较到的位置，每次将值向后挪动一次，最后将值插入最后比较位置
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
    }


    /**
     * 快速排序，
     * 每次取一个中间值，将数组中的元素分隔成大于中间值的一部分，和小于中间值的一部分。
     * 之后对上述两个部分重复该过程，直到每个部分的元素个数不能再细分为止。
     * 综上所述，使用递归方法方法实现最为有效
     *
     * @param arr   数组
     * @param start 本次需要进行比较部分的起始下标
     * @param end   本次需要进行比较部分的结束下标
     */
    private static void quickylySort(int[] arr, int start, int end) {
        if (start < end) {  //保证要被比较的数组段落确实存在，也保证递归不会无限制执行
            int i = start;
            int j = end;
            int tag = arr[i];
            while (i < j) {
                while (i < j && arr[j] >= tag) {
                    j--;
                }
                if (i < j) {
                    arr[i] = arr[j];
                }

                while (i < j && arr[i] <= tag) {
                    i++;
                }
                if (i < j) {
                    arr[j] = arr[i];
                }
            }
            arr[i] = tag;
            quickylySort(arr, start, i - 1);
            quickylySort(arr, i + 1, end);
        }
    }


    /**
     * 冒泡排序,以结果为正序排序为准：
     * 每次比较两个相邻的元素，将较大的置于后面位置，
     * 这样每一次对数组进行遍历比较过后都能得到一个最后位置的最大值。
     * 之后每一次遍历比较，上述最大值不再参与比较。
     *
     * @param arr 数组
     */
    private static void bubbSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }


}