手写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 positionwhile (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 pointint m = (l + (r - 1)) / 2;// Sort first and second halvesmergeSort(arr, l, m);mergeSort(arr, m + 1, r);// Merge the sorted halvesmerge(arr, l, m, r);}
}public void merge(int[] arr, int l, int m, int r) {// Find sizes of two subarrays to be mergedint n1 = m - l + 1;int n2 = r - m;// Create temp arraysint L[] = new int[n1];int R[] = new int[n2];//Copy data to temp arraysfor (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 subarrayint i = 0;// Initial index of second subarrayint j = 0;// Initial index of merged subarrayint 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 anywhile (i < n1) {arr[k] = L[i];i++;k++;}// Copy remaining elements of R[] if anywhile (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 堆排序

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

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

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 heapfor (int i = n - 1; i > 0; i--) {// Move current root to endint temp = arr[0];arr[0] = arr[i];arr[i] = temp;// Call max heapify on the reduced heapheapify(arr, i, 0);}
}void heapify(int[] arr, int n, int i) {int largest = i; // Initialize largest as rootint l = 2 * i + 1; // left = 2*i + 1int r = 2 * i + 2; // right = 2*i + 2// If left child is larger than rootif (l < n && arr[l] > arr[largest])largest = l;// If right child is larger than largest so farif (r < n && arr[r] > arr[largest])largest = r;// If largest is not rootif (largest != i) {int swap = arr[i];arr[i] = arr[largest];arr[largest] = swap;// Recursively heapify the affected sub-treeheapify(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 foundfor (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 arrayArrays.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 elementsfor (int i = 1; i < count.length; i++) {count[i] += count[i - 1];}// Build the output arrayfor (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 numbersfor (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;
}