常见的排序算法-Java版

冒泡排序

    public static void bubbleSort(int[] arr) {
        // 如果在某一次冒泡排序过程中没有交换元素则说明该数组已经有序
        boolean flag = true;
        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]) {
                    flag = false;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag)
                break;
        }
    }

选择排序

public static void selectSort(int[] arr) {
		// 第一种
    for (int i = 0; i < arr.length - 1; i++) {
        int min = arr[i];
        int maxIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[maxIndex] > arr[j]) {
                maxIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[maxIndex];
        arr[maxIndex] = temp;
    }
		// 第二种
    for (int i = 0; i < arr.length - 1; i++) {
        int min = arr[i];
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j];
                minIndex = j;
            }
        }
        if (i != minIndex) {
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }
}

插入排序

// 方法一
public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i ++) {
            int insertIndex = i;
            int insertValue = arr[i];
            while (insertIndex - 1 >= 0 && insertValue < arr[insertIndex - 1]) {
                arr[insertIndex] = arr[insertIndex - 1];    // arr[1] = arr[0]
                insertIndex --;
            }
            arr[insertIndex] = insertValue;
        }
    }
// 方法二
    public static void insertSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (arr[j] > tmp) {
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j + 1] = tmp;
        }
    }

希尔排序

    public static void shellSort(int[] arr) {
        // 步长 gap
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i ++) {
	              // 插入式间隔为gap的插入排序
                int shellIndex = i;
                int shellValue = arr[i];
                while (shellIndex - gap >= 0 && shellValue < arr[shellIndex - gap]) {
                    arr[shellIndex] = arr[shellIndex - gap];
                    shellIndex -= gap;
                }
                arr[shellIndex] = shellValue;
            }
        }
    }

快速排序

// 递归写法
public static void quickSort(int[] arr, int left, int right) {
  													// 排序的数组	最左边的索引	最右边的索引
        if (left >= right) {
            // 递归退出条件
            return;
        }
        int l = left;
        int r = right;
        while (l < r) {
            while (l < r && arr[r] >= arr[left]) r -- ;
            while (l < r && arr[l] <= arr[left]) l ++ ;
            if (r == l) {
                int temp = arr[r];
                arr[r] = arr[left];
                arr[left] = temp;
            } else {
                int temp = arr[r];
                arr[r] = arr[l];
                arr[l] = temp;
            }
        }
        quickSort(arr, left, l - 1);
        quickSort(arr, r + 1, right);
    }

归并排序

    public static void main(String[] args) {

        int[] ints = new int[]{23, -9, 78, 3, 34, 3, 0, 34, 23};
        // 临时存储合并之后的数组
        int[] temp = new int[ints.length];
        mergeSort(ints, 0, ints.length - 1, temp);
        System.out.println(Arrays.toString(ints));
    }

    public static void mergeSort(int[] arr, int left, int right, int[] temp){
        // 分
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, 0, mid, temp);   // 将左边部分继续分
            mergeSort(arr, mid + 1, right, temp);   // 将右边部分继续分
            // 合
            merge(arr, left, mid, right, temp);
        }
    }
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;
        int j = mid + 1;
        int t = 0;  // 临时数组的下标
        // 现将两个部分合并
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                i ++;t ++;
            } else {
                temp[t] = arr[j];
                j ++;t ++;
            }
        }
        // 如果左边的部分没有合并, 则接着i继续合并
        while (i <= mid) {
            temp[t] = arr[i];
            t ++; i ++;
        }
        // 如果右边的部分没有合并, 则接着j继续合并
        while (j <= right) {
            temp[t] = arr[j];
            t ++; j ++;
        }
        // 接着将temp里面的值填充到数组的指定位置
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t ++;tempLeft ++;
        }
    }

基数排序

public static void main(String[] args) {
        int[] ints = new int[]{24, 74, 3, 34, 14, 4, 34, 3434, 24, 3435, 324, 544, 234, 124};
        // 临时存储合并之后的数组
        radixSort(ints);
        System.out.println(Arrays.toString(ints));
    }

    // 1. 基数排序是对传统桶排序的扩展, 速度很快
    // 2. 基数排序法是属于稳定性的排序, 基数排序法的是效率高的稳定性排序法
    public static void radixSort(int[] arr) {
        int[][] bucket = new int[10][arr.length - 1];   // 就是基数里面所有的具体数值
        int[] bucketElementCounts = new int[10];    // 每个基数所存的元素个数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) max = arr[i];
        }
        int maxCount = (max + "").length();
        for (int i = 0; i < maxCount; i++) {
            // 把数组中的数都放在基数桶里
            for (int k = 0; k < arr.length; k++) {
                int value = arr[k] / (int) Math.pow(10, i) % 10;
                bucket[value][bucketElementCounts[value]] = arr[k];
                bucketElementCounts[value]++;
            }

            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k ++) {  // 遍历每个基数
                if (bucketElementCounts[k] != 0) {
                    for (int x = 0; x < bucketElementCounts[k]; x ++) { // 遍历每个基数桶的元素
                        arr[index] = bucket[k][x];
                        index++;
                    }
                }
                bucketElementCounts[k] = 0;
            }
        }
    }

桶排序

堆排序

计数排序

总结