排序算法总结

【冒泡排序】

冒泡排序算法思想： 冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，一次比较两个相邻的元素，并交换它们的位置，如果顺序不对则交换，直到没有需要交换的元素。通过多次遍历，将最大（或最小）的元素逐步“冒泡”到最后（或最前），完成排序。

JAVA代码实现： 以下是使用JAVA语言实现冒泡排序算法的示例代码：

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换arr[j]和arr[j+1]的位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，bubbleSort方法实现了冒泡排序算法，通过嵌套循环遍历数组并比较相邻元素的大小，进行交换操作。在main方法中，创建一个整型数组并调用bubbleSort方法对数组进行排序，最后输出排序后的结果。

【选择排序】

选择排序算法思想： 选择排序是一种简单直观的排序算法。它的思想是每次从未排序的部分中选择最小（或最大）的元素，然后与未排序部分的第一个元素交换位置，将该元素放到已排序部分的末尾。重复这个过程，直到所有元素都被排序。

JAVA代码实现： 以下是使用JAVA语言实现选择排序算法的示例代码：

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换arr[i]和arr[minIndex]的位置
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        selectionSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，selectionSort方法实现了选择排序算法，通过两层循环在每次外层循环中找到未排序部分的最小元素的索引，然后与未排序部分的第一个元素交换位置。在main方法中，创建一个整型数组并调用selectionSort方法对数组进行排序，最后输出排序后的结果。

【插入排序】

插入排序算法思想： 插入排序是一种简单且高效的排序算法。其基本思想是将一个元素插入到已经排好序的数组中的合适位置，使得插入后的数组仍然有序。具体实现时，从未排序部分取出一个元素，与已排序部分从后往前逐个比较，找到合适的位置插入。

JAVA代码实现： 以下是使用JAVA语言实现插入排序算法的示例代码：

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        insertionSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，insertionSort方法实现了插入排序算法，通过一个外层循环遍历未排序部分的元素，内层循环将当前元素插入到已排序部分的合适位置。在main方法中，创建一个整型数组并调用insertionSort方法对数组进行排序，最后输出排序后的结果。

【二分插入排序】

二分插入排序算法思想： 二分插入排序是插入排序的一种优化版本，通过利用二分查找的方式找到插入位置，减少比较次数。具体实现时，对于未排序部分的每个元素，使用二分查找在已排序部分中找到合适的插入位置，然后将元素插入到该位置。

JAVA代码实现： 以下是使用JAVA语言实现二分插入排序算法的示例代码：

public class BinaryInsertionSort {
    public static void binaryInsertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int left = 0;
            int right = i - 1;
            int insertIndex = binarySearch(arr, key, left, right);
            for (int j = i - 1; j >= insertIndex; j--) {
                arr[j + 1] = arr[j];
            }
            arr[insertIndex] = key;
        }
    }
​
    public static int binarySearch(int[] arr, int key, int left, int right) {
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == key) {
                return mid;
            } else if (arr[mid] < key) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        binaryInsertionSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，binaryInsertionSort方法实现了二分插入排序算法，通过二分查找找到插入位置，然后将元素插入到该位置。binarySearch方法用于在已排序部分中进行二分查找。在main方法中，创建一个整型数组并调用binaryInsertionSort方法对数组进行排序，最后输出排序后的结果。

【希尔排序】

希尔排序算法思想： 希尔排序是插入排序的一种改进版本，也称为缩小增量排序。其基本思想是将整个待排序的序列分割成若干个子序列，分别进行插入排序，然后逐步缩小增量，直至增量为1，最后对整个序列进行一次插入排序。希尔排序的关键在于选择合适的增量序列。

JAVA代码实现： 以下是使用JAVA语言实现希尔排序算法的示例代码：

public class ShellSort {
    public static void shellSort(int[] arr) {
        int n = arr.length;
        int gap = n / 2;
        while (gap > 0) {
            for (int i = gap; i < n; i++) {
                int temp = arr[i];
                int j = i;
                while (j >= gap && arr[j - gap] > temp) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = temp;
            }
            gap /= 2;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        shellSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，shellSort方法实现了希尔排序算法，通过不同的增量对子序列进行插入排序，最终完成整个序列的排序。在main方法中，创建一个整型数组并调用shellSort方法对数组进行排序，最后输出排序后的结果。

【快速排序】

快速排序算法思想： 快速排序是一种常用的排序算法，基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小，然后分别对这两部分继续进行排序，最终实现整个序列的排序。快速排序采用分治的思想，具体步骤如下：

1. 从序列中选择一个基准元素（通常选择第一个元素）；

2. 将序列中小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边；

3. 递归地对基准元素左右两部分进行快速排序。

JAVA代码实现： 以下是使用JAVA语言实现快速排序算法的示例代码：

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }
​
    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        int i = low + 1;
        int j = high;
        while (i <= j) {
            if (arr[i] <= pivot) {
                i++;
            } else if (arr[j] > pivot) {
                j--;
            } else {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[low];
        arr[low] = arr[j];
        arr[j] = temp;
        return j;
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，quickSort方法实现了快速排序算法，通过递归地对基准元素左右两部分进行排序来实现整个序列的排序。partition方法用于对序列进行分区操作，将小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边。在main方法中，创建一个整型数组并调用quickSort方法对数组进行排序，最后输出排序后的结果。

【归并排序】

归并排序算法思想： 归并排序是一种分治算法，基本思想是将待排序序列分为两部分，分别对这两部分进行排序，然后将排序好的子序列合并成一个完整的有序序列。具体步骤如下：

1. 将待排序序列不断二分，直到每个子序列只有一个元素；

2. 逐层合并相邻的子序列并排序，直到合并成一个完整的有序序列。

JAVA代码实现： 以下是使用JAVA语言实现归并排序算法的示例代码：

public class MergeSort {
    public static void mergeSort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(arr, low, mid);
            mergeSort(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
    }
​
    public static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[arr.length];
        int i = low;
        int j = mid + 1;
        int k = low;
        while (i <= mid && j <= high) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= high) {
            temp[k++] = arr[j++];
        }
        for (int index = low; index <= high; index++) {
            arr[index] = temp[index];
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        mergeSort(arr, 0, arr.length - 1);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，mergeSort方法实现了归并排序算法，通过递归地对子序列进行排序和合并来实现整个序列的排序。merge方法用于合并两个有序子序列为一个有序序列。在main方法中，创建一个整型数组并调用mergeSort方法对数组进行排序，最后输出排序后的结果。

【堆排序】

堆排序算法思想： 堆排序是一种选择排序，基本思想是将待排序序列构建成一个二叉堆（最大堆或最小堆），然后将堆顶元素与堆尾元素交换，调整堆使得剩余元素仍保持堆的性质，重复这个过程直到整个序列有序。

JAVA代码实现： 以下是使用JAVA语言实现堆排序算法的示例代码：

public class HeapSort {
    public static void heapSort(int[] arr) {
        int n = arr.length;
​
        // Build max heap
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }
​
        // Extract elements from heap one by one
        for (int i = n - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
​
            heapify(arr, i, 0);
        }
    }
​
    public static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
​
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }
​
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }
​
        if (largest != i) {
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;
​
            heapify(arr, n, largest);
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        heapSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

在上述代码中，heapSort方法实现了堆排序算法，通过构建最大堆和交换堆顶元素来实现排序。heapify方法用于调整堆，使得以节点i为根节点的子树满足堆的性质。在main方法中，创建一个整型数组并调用heapSort方法对数组进行排序，最后输出排序后的结果。

【桶排序】

桶排序（Bucket Sort）是一种排序算法，它根据元素的值将元素分配到不同的桶（桶可以是数组、链表等数据结构），然后对每个桶中的元素进行排序，最后按照顺序将所有桶中的元素合并得到有序序列。

JAVA代码实现： 以下是使用JAVA语言实现桶排序算法的示例代码：

import java.util.ArrayList;
import java.util.Collections;
​
public class BucketSort {
    public static void bucketSort(int[] arr, int bucketSize) {
        if (arr == null || arr.length == 0) {
            return;
        }
​
        int maxVal = arr[0];
        int minVal = arr[0];
        for (int num : arr) {
            maxVal = Math.max(maxVal, num);
            minVal = Math.min(minVal, num);
        }
​
        int bucketCount = (maxVal - minVal) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(bucketCount);
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new ArrayList<>());
        }
​
        for (int num : arr) {
            int bucketIndex = (num - minVal) / bucketSize;
            buckets.get(bucketIndex).add(num);
        }
​
        int index = 0;
        for (ArrayList<Integer> bucket : buckets) {
            Collections.sort(bucket);
            for (int num : bucket) {
                arr[index++] = num;
            }
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bucketSort(arr, 10);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

在上述代码中，bucketSort方法实现了桶排序算法，根据元素的值将元素分配到不同的桶中，然后对每个桶中的元素进行排序，最后按顺序将所有桶中的元素合并得到有序序列。在main方法中，创建一个整型数组并调用bucketSort方法对数组进行排序，最后输出排序后的结果。

【基数排序】

基数排序（Radix Sort）是一种非比较型的排序算法，它将整数按照位数进行排序，从最低位到最高位依次排序。基数排序可以分为 LSD（从低位到高位）和 MSD（从高位到低位）两种方式。

JAVA代码实现： 以下是使用JAVA语言实现基数排序算法的示例代码（LSD方式）：

import java.util.Arrays;
​
public class RadixSort {
    public static void radixSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
​
        int maxVal = Arrays.stream(arr).max().getAsInt();
        int exp = 1;
        int n = arr.length;
        int[] output = new int[n];
​
        while (maxVal / exp > 0) {
            int[] count = new int[10];
​
            for (int i = 0; i < n; i++) {
                count[(arr[i] / exp) % 10]++;
            }
​
            for (int i = 1; i < 10; i++) {
                count[i] += count[i - 1];
            }
​
            for (int i = n - 1; i >= 0; i--) {
                output[count[(arr[i] / exp) % 10] - 1] = arr[i];
                count[(arr[i] / exp) % 10]--;
            }
​
            System.arraycopy(output, 0, arr, 0, n);
            exp *= 10;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
        radixSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

在上述代码中，radixSort方法实现了基数排序算法（LSD方式），按照整数的各个位数进行排序。在main方法中，创建一个整型数组并调用radixSort方法对数组进行排序，最后输出排序后的结果。

【计数排序】

计数排序（Counting Sort）是一种非比较型的排序算法，适用于排序一定范围内的整数元素。计数排序的基本思想是统计每个元素出现的次数，然后根据统计信息将元素放回到正确的位置上。

JAVA代码实现： 以下是使用JAVA语言实现计数排序算法的示例代码：

public class CountingSort {
    public static void countingSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
​
        int maxVal = Integer.MIN_VALUE;
        for (int num : arr) {
            maxVal = Math.max(maxVal, num);
        }
​
        int[] count = new int[maxVal + 1];
        int[] output = new int[arr.length];
​
        for (int num : arr) {
            count[num]++;
        }
​
        for (int i = 1; i <= maxVal; i++) {
            count[i] += count[i - 1];
        }
​
        for (int i = arr.length - 1; i >= 0; i--) {
            output[count[arr[i]] - 1] = arr[i];
            count[arr[i]]--;
        }
​
        System.arraycopy(output, 0, arr, 0, arr.length);
    }
​
    public static void main(String[] args) {
        int[] arr = {4, 2, 2, 8, 3, 3, 1};
        countingSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

在上述代码中，countingSort方法实现了计数排序算法，首先统计每个元素出现的次数，然后根据统计信息将元素放回到正确的位置上。在main方法中，创建一个整型数组并调用countingSort方法对数组进行排序，最后输出排序后的结果。