九大排序算法（Java实现）

标签：排序算法   sel   插入   ati   java   wap   ready   public   索引   

1、冒泡排序

public class Bubble_sort {

    /**
     * 公共冒泡排序接口
     * @param arr 带排序数组
     */
    public static void sort(int[] arr) {
        if (arr == null) return;
        int len = arr.length;
        for (int j = len - 1; j > 0; j--) {
            for (int i = 0; i < j; i++) {
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }

    /**
     * 通用交换方法
     * @param arr  数组
     * @param i    元素1索引
     * @param j    元素2索引
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}    

2、选择排序

public class Select_sort {

    /**
     * 选择排序公共接口
     * @param arr
     */
    public static void sort(int[] arr) {
        if (arr == null) return;
        int len = arr.length;
        for (int j = len - 1; j > 0; j--) {
            int max = j;
            for (int i = 0; i <= j; i++) {
                if (arr[i] >= arr[max]) {
                    max = i;
                }
                swap(arr, max, j);
            }
        }
    }

    /**
     * 通用交换方法
     * @param arr  数组
     * @param i    元素1索引
     * @param j    元素2索引
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

3、插入排序

public class Insertion_sort {

    /**
     * 插入排序
     * @param arr 待排序数组
     */
    public static void sort(int[] arr) {
        if (arr == null) return;
        // 待排序区间 [1...len-1]
        for (int j = 1; j < arr.length; j++) {
            // 比较元素
            int key = arr[j];
            int i = j - 1;
            while (i >= 0 && arr[i] > key) {
                arr[i + 1] = arr[i];
                i--;
            }
            arr[i + 1] = key;
        }
    }
}

4、快速排序

public class Quick_sort {
    private static final int MIN_VALUE = 7;

    public static void sort(int[] arr) {
        if (arr == null) return;
         sorting(arr, 0, arr.length - 1);
    }

    private static void sorting(int[] arr, int lo, int hi) {
        if (lo >= hi) return;
        if (hi- lo <= MIN_VALUE) Insertion_sort.sort(arr);
        // 切分点
        int p = partition(arr, lo, hi);
        sorting(arr, lo, p - 1);
        sorting(arr, p + 1, hi);
    }

    /**
     * 切分方法
     * @param arr 数组
     * @param lo  左边界
     * @param hi  右边界
     * @return
     */
    private static int partition(int[] arr, int lo, int hi) {
        int key = arr[hi];
        // 右边界
        int right = lo - 1;
        for (int i = lo; i < hi; i++) {
            if (arr[i] <= key) {
                right++;
                swap(arr, right, i);
            }
        }
        swap(arr, right + 1, hi);
        return right + 1;
    }

    /**
     * 通用数组交换
     * @param arr  数组
     * @param a    元素1索引
     * @param b    元素2索引
     */
    private static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

6、归并排序

public class Merge_sort {
    /**
     * 转为插入排序的临界值
     */
    private static final int MIN_SIZE = 7;

    /**
     * 公共归并排序
     * @param arr 待排序数组
     */
    public static void sort(int[] arr) {
        if (arr == null) return;
        int[] temp = new int[arr.length];
        sorting(arr, temp, 0, arr.length - 1);
    }

    /**
     * 归并排序（私有）
     */
    private static void sorting(int[] arr, int[] temp, int lo, int hi) {
        if (lo >= hi) return;
        // less than MIN_SIZE  user insertion_sort
        if (hi - lo <= MIN_SIZE) Insertion_sort.sort(arr);

        int mid = (lo + hi) >>> 1;
        sorting(arr, temp,  lo, mid);
        sorting(arr, temp, mid + 1, hi);
        merge(arr, temp, lo, mid, hi);
    }

    /**
     * 归并方法
     */
    private static void merge(int[] arr, int[] temp,  int lo, int mid, int hi) {
        for (int i = lo; i <= hi; i++) {
            temp[i] = arr[i];
        }
        int i = lo;
        int j = mid + 1;
        for (int k = lo; k <= hi; k++) {
            if (i > mid) {
                arr[k] = temp[j++];
            } else if (j > hi) {
                arr[k] = temp[i++];
            } else if (temp[i] <= temp[j]) {
                arr[k] = temp[i++];
            } else {
                arr[k] = temp[j++];
            }
        }
    }
}

7、堆排序

public class Heap_sort {

    /**
     * 公共堆排序方法
     * @param arr
     */
    public static void sort(int[] arr) {
        int len = arr.length;

        // 1.堆有序
        for (int k = (len / 2) - 1; k >= 0; k--) {
            sink(arr, k, len);
        }

        // 2.交换，调整
        while (len  > 1) {
            swap(arr, 0, len - 1);
            len--;
            sink(arr, 0, len);
        }
    }

    /**
     * 下沉操作
     * 构建堆有序：任意节点大于等于其子节点的值
     */
    public static void sink(int[] arr, int k, int len) {
        while ((2 * k + 1) < len) {
            int idx = 2 * k + 1;
            if (idx < len - 1 && arr[idx] < arr[idx + 1]) {
                idx++;
            }
            // already heap sorted
            if (arr[idx] <= arr[k]) break;
            swap(arr, k, idx);
            k = idx;
        }
    }

    /**
     * 通用数组元素交换方法
     * @param arr  数组
     * @param i    元素 1下标
     * @param j    元素 2下标
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

8、希尔排序

public class Shell_sort {
    public static void sort(int[] arr) {
        int len = arr.length;
        int h = 1;
        while (h < len / 3) {
            h = 3 * h + 1;
        }

        while (h >= 1) {
            // 内部包裹一个插入排序
            for (int j = h; j < len; j++) {
                int key = arr[j];
                int i = j - h;
                while (i >= 0 && arr[i] > key) {
                    arr[i + h] = arr[i];
                    i -= h;
                }
                arr[i + h] = key;
            }
            h = h / 3;
        }
    }
	// 数组交换
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

9、计数排序

public class Count_sort {

    public static void sort(int[] arr, int max) {
        int[] aus = new int[max + 1];
        // 统计
        for (int num : arr) {
            aus[num] += 1;
        }
        // 重写
        int idx = 0;
        for (int i = 0; i < aus.length; i++) {
            while (aus[i] != 0) {
                arr[idx] = i;
                idx++;
                aus[i] -= 1;
            }
        }
    }
}

九大排序算法（Java实现）

标签：排序算法   sel   插入   ati   java   wap   ready   public   索引   

原文地址：https://www.cnblogs.com/xfzhao1419/p/14017205.html