本文共 4609 字，大约阅读时间需要 15 分钟。

十大排序算法总结+工具类

总结

算法的核心在于思想，而非具体实现。掌握其核心思想后，便能理解他人代码，或能自行编写相似的代码。每种编程语言都内置优化后的排序算法，其性能远高于我们手动实现的版本。因此，在实际开发中，只需熟练掌握语言内置的排序方法即可。

工具类

以下是常见排序算法的实现代码，供参考：

插入排序

private static void selectionSort(int[] arr, int len) {    for (int i = 0; i < len - 1; i++) {        int min = i;        for (int j = i + 1; j < len; j++) {            if (arr[j] < arr[min]) {                min = j;            }        }        swap(arr, i, min);    }}

冒泡排序

private static void bubbleSort(int[] arr, int len) {    for (int i = len - 1; i > 0; i--) {        for (int j = 0; j < i; j++) {            if (arr[j] > arr[j + 1]) {                swap(arr, j, j + 1);            }        }    }}

插入排序

private static void insertionSort(int[] arr, int len) {    for (int i = 1; i < len; i++) {        for (int j = i; j > 0; j--) {            if (arr[j] < arr[j - 1]) {                swap(arr, j, j - 1);            }        }    }}

希尔排序

private static void shellSort(int[] arr, int len) {    int h = 1;    while (h <= len / 3) {        h = h * 3 + 1;    }    for (int gap = h; gap > 0; gap = (gap - 1) / 3) {        for (int i = gap; i < len; i++) {            for (int j = i; j > gap - 1; j -= gap) {                if (arr[j] < arr[j - gap]) {                    swap(arr, j, j - gap);                }            }        }    }}

堆排序

private static void heapSort(int[] arr, int len) {    for (int i = len; i > 0; i--) {        heapify(arr, i);        swap(arr, i - 1, 0);    }}

堆化

private static void heapify(int[] arr, int len) {    for (int i = len / 2 - 1; i >= 0; i--) {        int max = i;        if (2 * i + 1 < len && arr[max] < arr[2 * i + 1]) {            max = 2 * i + 1;        }        if (2 * i + 2 < len && arr[max] < arr[2 * i + 2]) {            max = 2 * i + 2;        }        swap(arr, i, max);    }}

快速排序

private static void quickSort(int[] arr, int left, int right) {    if (left >= right) {        return;    }    int mid = partition(arr, left, right);    quickSort(arr, left, mid - 1);    quickSort(arr, mid + 1, right);}

归并排序

private static void mergeSort(int[] arr, int left, int right) {    if (left >= right) {        return;    }    int mid = left + (right - left) / 2;    mergeSort(arr, left, mid);    mergeSort(arr, mid + 1, right);    merge(arr, left, mid + 1, right);}

计数排序

private static void countSort(int[] arr, int len) {    int[] count = new int[10];    for (int i = 0; i < len; i++) {        count[arr[i]]++;    }    for (int i = 1; i < count.length; i++) {        count[i] += count[i - 1];    }    for (int i = len - 1; i >= 0; i--) {        int index = count[arr[i]];        result[--count[arr[i]]] = arr[i];    }    System.arraycopy(result, 0, arr, 0, len);}

基数排序

private static void radixSort(int[] arr, int len) {    int max = arr[0];    int min = arr[0];    for (int i = 1; i < len; i++) {        if (max < arr[i]) {            max = arr[i];        }        if (min > arr[i]) {            min = arr[i];        }    }    if (min < 0) {        for (int i = 0; i < len; i++) {            arr[i] -= min;        }        max -= min;    }    int n = (max + "").length();    int[] count = new int[10];    int[] temp = new int[len];    for (int i = 0; i < n; i++) {        int m = (int) Math.pow(10, i);        for (int j = 0; j < len; j++) {            int div = arr[j] / m % 10;            count[div]++;        }        for (int j = 1; j < count.length; j++) {            count[j] += count[j - 1];        }        for (int k = len - 1; k >= 0; k--) {            int div = arr[k] / m % 10;            temp[--count[div]] = arr[k];        }        System.arraycopy(temp, 0, arr, 0, len);        Arrays.fill(count, 0);    }    if (min < 0) {        for (int i = 0; i < len; i++) {            arr[i] += min;        }    }}

桶排序

private static void bucketSort(int[] arr, int bucketLen) {    int min = arr[0];    int max = arr[0];    for (int i = 1; i < arr.length; i++) {        if (min > arr[i]) {            min = arr[i];        }        if (max < arr[i]) {            max = arr[i];        }    }    int bucketCount = (max - min) / bucketLen + 1;    List
   
    
     > lists = new ArrayList<>(bucketCount);    for (int i = 0; i < bucketCount; i++) {        lists.add(new ArrayList<>());    }    for (int k : arr) {        lists.get((k - min) / bucketLen).add(k);    }    for (int i = 0; i < bucketCount; i++) {        Collections.sort(lists.get(i));    }    int index = 0;    for (int i = 0; i < bucketCount; i++) {        for (int j = 0; j < lists.get(i).size(); j++) {            arr[index++] = lists.get(i).get(j);        }    }}
    
   

最后

以上代码仅为排序算法的实现示例，具体细节可根据实际需求进行调整。如需了解某种算法的详细实现或应用场景，可以参考相关技术文档或文章。

转载地址：http://lobcz.baihongyu.com/