手写8大排序算法Java版

如何手写8大排序算法：从入门到精通

排序算法是计算机科学中最基本的算法之一，几乎所有编程语言的面试都会涉及到排序算法的问题。掌握排序算法不仅能够帮助你更好地理解数据结构和算法，还能提升你解决实际问题的能力。本文将带你从零开始，手写8种常见的排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序和计数排序。

引言

排序算法有很多种，每种算法都有其特定的使用场景和优缺点。在开始之前，我们需要了解一些基本的概念：

• 时间复杂度：算法执行的时间长短。
• 空间复杂度：算法执行过程中所需的存储空间。
• 稳定性：排序算法的稳定性指的是相等元素的相对顺序在排序后是否保持不变。

第1部分：基础排序算法

1.1 冒泡排序

冒泡排序是一种简单的排序算法，通过重复遍历待排序的数列，比较每对相邻元素，如果顺序错误就交换它们。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

public void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 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;
            }
        }
    }
}

1.2 选择排序

选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在数列的起始位置，直到全部待排序的数据元素排完。

public void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // 交换 arr[minIndex] 和 arr[i]
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

1.3 插入排序

插入排序的工作方式是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

public void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int key = arr[i];
        int j = i - 1;
        // Move elements of arr[0..i-1], that are greater than key,
        // to one position ahead of their current position
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

第2部分：分治排序算法

2.1 归并排序

归并排序是一种分治算法，将已有序的子序列合并为更长的有序序列，即归并。“分而治之”是分治法的核心思想，将一个难以直接解决的大问题，拆分成一些相对简单的小问题，寻找到解决小问题的解法，然后合并这些解来构成原本问题的解。

public void mergeSort(int[] arr, int l, int r) {
    if (l < r) {
        // Find the middle point
        int m = (l + (r - 1)) / 2;
        // Sort first and second halves
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        // Merge the sorted halves
        merge(arr, l, m, r);
    }
}

public void merge(int[] arr, int l, int m, int r) {
    // Find sizes of two subarrays to be merged
    int n1 = m - l + 1;
    int n2 = r - m;
    // Create temp arrays
    int L[] = new int[n1];
    int R[] = new int[n2];
    //Copy data to temp arrays
    for (int i = 0; i < n1; ++i)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; ++j)
        R[j] = arr[m + 1 + j];
    // Merge the temp arrays
    // Initial index of first subarray
    int i = 0;
    // Initial index of second subarray
    int j = 0;
    // Initial index of merged subarray
    int k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    // Copy remaining elements of L[] if any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    // Copy remaining elements of R[] if any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

2.2 快速排序

快速排序是另一种分治算法，它采用了分治法的一个非常重要的思想，即“以空间换时间”。快速排序的基本思想是：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序操作，以达到整个序列有序。

public void quickSort(int[] arr, int l, int r) {
    if (l < r) {
        int pivotIndex = partition(arr, l, r);
        quickSort(arr, l, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, r);
    }
}

public int partition(int[] arr, int l, int r) {
    int pivot = arr[r];
    int i = l - 1;
    for (int j = l; j < r; j++) {
        if (arr[j] < pivot) {
            i++;
            // swap arr[i] and arr[j]
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // swap arr[i+1] and arr[r] (or pivot)
    int temp = arr[i + 1];
    arr[i + 1] = arr[r];
    arr[r] = temp;
    return i + 1;
}

第3部分：高级排序算法

3.1 堆排序

堆排序是一种基于比较的排序算法，通过利用二叉堆的数据结构所设计的一种排序算法。它分为两个阶段：

1. 建堆：将待排序序列构造成一个二叉堆，根据（最大堆或最小堆）的定义，此时整个序列的最大（或最小）元素在堆的根节点。
2. 排序：将根节点与最后一个节点交换，缩小堆的范围，然后继续调整堆，再交换第一个元素和当前堆的最后一个元素，如此反复直到堆为空。

public void heapSort(int[] arr) {
    int n = arr.length;

    // Build heap (rearrange array)
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // One by one extract an element from heap
    for (int i = n - 1; i > 0; i--) {
        // Move current root to end
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        // Call max heapify on the reduced heap
        heapify(arr, i, 0);
    }
}

void heapify(int[] arr, int n, int i) {
    int largest = i; // Initialize largest as root
    int l = 2 * i + 1; // left = 2*i + 1
    int r = 2 * i + 2; // right = 2*i + 2

    // If left child is larger than root
    if (l < n && arr[l] > arr[largest])
        largest = l;

    // If right child is larger than largest so far
    if (r < n && arr[r] > arr[largest])
        largest = r;

    // If largest is not root
    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        // Recursively heapify the affected sub-tree
        heapify(arr, n, largest);
    }
}

3.2 希尔排序

希尔排序是插入排序的一种更高效的改进版本。它通过将原始数据分成多个子序列，分别进行直接插入排序。待所有子序列有序后，再对全体数据进行一次直接插入排序。

public 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;
            // Shift earlier gap-sorted elements up until the correct location for arr[i] is found
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
        gap /= 2; // Reduce gap for next element
    }
}

3.3 计数排序

计数排序是一种线性时间复杂度的排序算法，适用于一定范围内的整数排序。它通过计算每个元素出现的次数，然后按顺序构建一个新的数组。

public void countingSort(int[] arr) {
    int max = findMax(arr);
    int min = findMin(arr);
    int range = max - min + 1;
    int[] count = new int[range];
    int[] output = new int[arr.length];

    // Initialize count array
    Arrays.fill(count, 0);

    // Store counts of each element in count[]
    for (int i = 0; i < arr.length; i++) {
        count[arr[i] - min]++;
    }

    // Modify count so that it now contains the actual position of elements
    for (int i = 1; i < count.length; i++) {
        count[i] += count[i - 1];
    }

    // Build the output array
    for (int i = arr.length - 1; i >= 0; i--) {
        output[count[arr[i] - min] - 1] = arr[i];
        count[arr[i] - min]--;
    }

    // Copy the output array to arr, so that arr contains the sorted numbers
    for (int i = 0; i < arr.length; i++) {
        arr[i] = output[i];
    }
}

public int findMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

public int findMin(int[] arr) {
    int min = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

第4部分：算法比较与选择

在实际应用中，选择哪种排序算法取决于多种因素，包括数据的大小、特性、以及对时间复杂度和空间复杂度的要求。以下是一些基本的指导原则：

• 数据量小：如果数据量很小，使用简单的排序算法（如插入排序或选择排序）即可。
• 数据量较大：对于大量数据，更倾向于使用分治算法（如快速排序或归并排序）。
• 数据部分有序：如果数据部分有序，插入排序和希尔排序效率会更高。
• 稳定性要求：如果需要保持相等元素的相对顺序，选择稳定的排序算法（如插入排序、归并排序）。
• 空间复杂度：如果内存空间有限，选择空间复杂度低的算法（如计数排序或桶排序）。
• 时间复杂度：如果对性能要求极高，选择平均时间复杂度低的算法（如快速排序或归并排序）。

又到了说再见的时候了

排序算法是编程中不可或缺的一部分，掌握它们对于任何软件开发者来说都是基本技能。通过本文，我们学习了8种不同的排序算法，包括它们的实现和适用场景。希望读者能够通过实践加深对这些算法的理解，并在实际项目中灵活运用。