排序算法汇总---Java实现各个排序

排序算法汇总

下图来自菜鸟教程：


下面所有方法都有static关键字，因为测试的时候需要被main函数调用，故添加static。
若需要c++版本的算法实现，可参考下面博文连接
排序算法汇总—C++实现各个排序

1、冒泡排序

    // 冒泡排序
    static void bubble_sort(int[] arr) {
   
        for (int i = 0; i < arr.length - 1; i++) {
    // n-1趟
            for (int j = 0; j < arr.length - i - 1; j++) {
    // n-趟数-1
                if (arr[j] > arr[j + 1]) {
   
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

2、直接插入排序

    // 插入排序
    static void insert_sort(int[] arr) {
   
        for (int i = 1; i < arr.length; i++) {
   
            for (int j = i; j > 0; j--) {
   
                if (arr[j] < arr[j - 1]) {
   
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }

3、希尔排序

改进的插入排序

    // 希尔排序（改进的插入排序）
    static void shell_sort(int[] arr) {
   
        // 先求出间隔h
        int h = 1;
        while (h <= arr.length / 3) {
   
            h = h * 3 + 1; // Knuth
        }
        for (int i = h; i < arr.length; i++) {
   
            for (int j = i; j > h - 1; j -= h) {
   
                if (arr[j] < arr[j - h]) {
   
                    int temp = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = temp;
                }
            }
        }
    }

4、选择排序

    // 选择排序
    static void select_sort(int[] arr) {
   
        for (int i = 0; i < arr.length - 1; i++) {
   
            // 找最小值
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
   
                if (arr[j] < arr[min]) {
   
                    min = j;
                }
            }
            // 判断当前值是否需要与最小值交换
            if (min != i) {
   
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }

5、快速排序

// 快速排序
    // 先写出每一次划分的方法
    static int partition(int[] arr, int low, int high) {
   
        int mid = low + ((high - low) >> 1);
        int temp = arr[low];
        arr[low] = arr[mid];
        arr[mid] = temp;
        int pivot = arr[low];
        while (low < high) {
   
            while (low < high && pivot <= arr[high]) {
   
                high--;
            }
            arr[low] = arr[high];
            while (low < high && pivot >= arr[low]) {
   
                low++;
            }
            arr[high] = arr[low];
        }
        // 此时low == high
        arr[low] = pivot;
        return low;
    }

    // 接下来写快速排序的递归
    static void quick_sort(int[] arr, int low, int high) {
   
        if (low < high) {
   
            int mid = partition(arr, low, high);
            quick_sort(arr, low, mid - 1);
            quick_sort(arr, mid + 1, high);
        }
    }

6、归并排序

// 归并排序
    // 首先写归并
    static void merge(int[] arr, int low, int mid, int high) {
   
        int i = low;
        int j = mid + 1;
        int k = 0;
        int[] temp = new int[high - low + 1];
        while (i <= mid && j <= high) {
   
            if (arr[i] <= arr[j]) {
   
                temp[k++] = arr[i++];
            } else {
   
                temp[k++] = arr[j++];
            }
        }
        while (i