排序算法

排序算法

写了几个排序算法, 记录一下

package com.kayak.poc.mytest;

import java.util.Arrays;

public class Sort {

    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        //int[] arr = {53, 3, 542, 748, 87, 14, 123, 989};
        //bubbleSort(arr);
        //selectSort(arr);
        //insertSort(arr);
        //shellSort1(arr);
        //shellSort2(arr);
        int[] temp = new int[10];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 归并排序
     * 利用递归把需要排序的数组分解成一个小数组排序, 直到最后只剩下两个元素排序, 然后利用回溯把数组合并起来
     *
     * @param arr
     */
    private static void mergeSort(int[] arr, int start, int end, int[] temp) {
        if (start < end) {

            int mid = (start + end) / 2;

            mergeSort(arr, start, mid, temp);

            mergeSort(arr, mid + 1, end, temp);

            merge(arr, start, end, mid, temp);

        }
    }

    /**
     * @param arr   原始数组
     * @param start 合并的开始索引
     * @param end   合并的结束索引
     * @param mid   合并的中位索引
     * @param temp  合并的临时数组
     */
    private static void merge(int[] arr, int start, int end, int mid, int[] temp) {
        int index = 0;
        int left = start;
        int right = mid+1;

        //把两个逻辑上分开的数组按大小顺序放入临时数组
        while (left <= mid && right <= end) {
            if (arr[left] < arr[right]) {
                temp[index] = arr[left];
                index++;
                left++;
            } else {
                temp[index] = arr[right];
                index++;
                right++;
            }
        }

        //左边的逻辑数组有可能还有值,按顺序放入临时数组
        while (left <= mid) {
            temp[index] = arr[left];
            left++;
            index++;
        }

        //右边的逻辑数组有可能还有值, 按顺序放入临时数组
        while (right <= end) {
            temp[index] = arr[right];
            right++;
            index++;
        }

        //把临时数组放入正式的数组
        index = 0;
        int tempLeft = start;
        while (tempLeft<=end){
            arr[tempLeft] = temp[index];
            index++;
            tempLeft++;
        }


    }


    /**
     * 基数排序 这个版本无法处理负数以及小数,  另外数据量太大容易导致内存溢出
     * 1. 先找到数组中最大的那个数, 并确定要循环多少次
     * 2. 创建一个二维数组, 用于存放排序, 在创建一个一维数组, 用于记录二维数组存放的数据指针
     * 3. 第一次循环, 把数组中的数据取个位数, 分别放入对应的桶中, 然后按照顺序取出放回原数组,并将数据指针数组置为 0
     * 4. 第二次循环, 把数组中的数据取十位数, 分别放入对应的桶中, 然后按照顺序取出放回原数组,并将数据指针数组置为 0
     * 5. 循环完成后就完成了排序
     *
     * @param arr
     */
    private static void radixSort(int[] arr) {

        int[][] bucket = new int[10][arr.length];
        int[] elementCount = new int[10];

        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        int maxLength = (max + "").length();

        for (int x = 0, y = 1; x < maxLength; x++, y *= 10) {

            //放入桶中
            for (int i = 0; i < arr.length; i++) {
                int n = arr[i] / y % 10;
                bucket[n][elementCount[n]] = arr[i];
                elementCount[n] = elementCount[n] + 1;
            }

            int index = 0;
            //取出放回原数组
            for (int a = 0; a < elementCount.length; a++) {
                for (int i = 0; i < elementCount[a]; i++) {
                    arr[index] = bucket[a][i];
                    index++;
                }
                elementCount[a] = 0;
            }

        }

    }


    /**
     * 希尔排序交换法
     * 希尔排序是插入排序的优化版
     * 先对半分组, 再遍历分好的组, 最后把组内元素进行排序
     * 再对半分组, 遍历分好的组, 把组内元素进行排序
     * 知道分组为 0
     *
     * @param arr
     */
    private static void shellSort1(int[] arr) {
        int temp;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }


    /**
     * 希尔排序第二种, 移位法
     *
     * @param arr
     */
    private static void shellSort2(int[] arr) {
        int temp;

        int insertIndex;
        int insertVal;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                insertIndex = i;
                insertVal = arr[i];
                if (arr[insertIndex] < arr[insertIndex - gap]) {
                    while (insertIndex - gap >= 0 && insertVal < arr[insertIndex - gap]) {
                        arr[insertIndex] = arr[insertIndex - gap];
                        insertIndex -= gap;
                    }
                    arr[insertIndex] = insertVal;
                }
            }
        }


    }


    /**
     * 插入排序
     * 思路: 把数组分成两个部分 , 第一个部分当成有序数组, 第二个部分当成无序数组
     * 循环第一步 : 先把第一个数当做有序, 其他数当做无序, 拿无序的第一个数来和有序数组比较并确定位置
     * 第二部: 经过第一步已经有两个数是有序的, 其他数当做无序数组, 继续拿无序数组第一个数来有序数组比较并确定位置
     * 重复上述第二步直到全部排序完成
     *
     * @param arr
     */
    private static void insertSort(int[] arr) {

        //定义每次无序数组要进行比较的索引和值
        int insertIndex = 0;
        int insertVal = 0;

        for (int i = 1; i < arr.length; i++) {

            //因为我要和前一个值进行比较, 所以比较值的索引-1
            insertIndex = i - 1;
            //用一个变量保存比较值
            insertVal = arr[i];

            //如果索引小于0就代表没有数据可以比较了, 这个值就是最小的
            //如果比较值小于索引值, 就把比较值往后挪一个位置, 覆盖了我们的比较值无所谓, 因为我们有变量保存了
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            //如果没有进入while循环,就代表我们已经找到了要插入的位置,
            // 因为我们在while循环里面 -- 操作, 所以要加1
            if (insertIndex + 1 == i)
                arr[insertIndex + 1] = insertVal;

        }
    }


    /**
     * 选择排序
     *
     * @param arr
     */
    private static void selectSort(int[] arr) {

        int temp;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

    /**
     * 冒泡排序
     *
     * @param arr
     */
    private static void bubbleSort(int[] arr) {

        int temp;
        for (int i = 0; i < arr.length; i++) {
            boolean flag = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] < arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

            if (!flag) {
                break;
            }
            // System.out.println("第"+i+"次  "+Arrays.toString(arr));
        }
    }
}