十大经典算法
十大经典算法
-
- 1. 冒泡排序（Bubble Sort）
- 2. 选择排序（Selection Sort）
- 3. 插入排序（Insertion Sort）
- 4. 快速排序（Quick Sort）
- 5. 归并排序（Merge Sort）
- 6. 堆排序（Heap Sort）
- 7. 计数排序（Counting Sort）
- 8. 桶排序（Bucket Sort）
- 9. 基数排序（Radix Sort）
- 10. 希尔排序（Shell Sort）
1. 冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
实现代码如下：
public static void main(String[] args) {
int[] arr = {5, 8, 2, 1, 6, 3, 7, 4};
bubbleSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
if (!swapped) {
break;
}
}
}
输出结果
1 2 3 4 5 6 7 8
2. 选择排序（Selection Sort）
选择排序是一种简单直观的排序算法。它的工作原理如下：
1、在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
2、再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；
3、重复第二步，直到所有元素均排序完毕；
实现代码如下：
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] + " ");
}
}
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;
}
}
if (minIndex != i) {
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
}
输出结果
排序后的数组：
11 12 22 25 34 64 90
3. 插入排序（Insertion Sort）
插入排序的原理是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。具体步骤如下：
1、从第一个元素开始，该元素可以认为已经被排序；
2、取出下一个元素，在已经排序的元素序列中从后向前扫描；
3、如果被扫描的元素（已排序）大于新元素，将该元素后移一位；
4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5、将新元素插入到该位置后；
6、重复步骤2~5；
实现代码如下：
public static void main(String[] args) {
int[] arr = {4, 3, 2, 10, 12, 1, 5, 6};
insertionSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
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 = j - 1;
}
arr[j + 1] = key;
}
}
输出结果
排序后的数组：
1 2 3 4 5 6 10 12
4. 快速排序（Quick Sort）
快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
快速排序的实现步骤如下：
1、选择一个基准元素，通常选择数组的第一个元素或者最后一个元素。
2、将数组分为两部分，一部分是小于基准元素的，另一部分是大于基准元素的。
3、对这两部分分别进行快速排序。
4、将排序后的两部分和基准元素合并
实现代码如下：
public static void main(String[] args) {
int[] arr = {3, 8, 2, 5, 1, 4, 7, 6};
quickSort(arr, 0, arr.length - 1);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static int partition(int[] arr, int low, int high) {
int pivot = arr[low];
while (low < high) {
while (low < high && arr[high] >= pivot) {
high--;
}
arr[low] = arr[high];
while (low < high && arr[low] <= pivot) {
low++;
}
arr[high] = arr[low];
}
arr[low] = pivot;
return low;
}
输出结果
1 2 3 4 5 6 7 8
5. 归并排序（Merge Sort）
归并排序（Merge Sort）是一种分治算法，其基本思想是将待排序的序列分成两个子序列，对子序列分别进行排序，然后将排序后的子序列合并成一个有序序列。具体步骤如下：
1、如果序列长度为1或0，直接返回该序列，因为长度为1或0的序列已经是有序的。
2、将序列分成两个子序列，每个子序列的长度为原序列长度的一半。
3、对两个子序列分别进行归并排序。
4、将排序后的子序列合并成一个有序序列。
实现代码如下：
public static void main(String[] args) {
int[] arr = {5, 8, 6, 3, 9, 2, 1, 7};
mergeSort(arr, 0, arr.length - 1);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void merge(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= right) {
temp[k++] = arr[j++];
}
for (int p = 0; p < temp.length; p++) {
arr[left + p] = temp[p];
}
}
输出结果
1 2 3 5 6 7 8 9
6. 堆排序（Heap Sort）
堆排序（Heap Sort）是一种基于二叉堆的比较排序算法。它的基本思想是将待排序的序列构造成一个大顶堆（或小顶堆），然后将堆顶元素与末尾元素交换，再调整剩余元素为大顶堆（或小顶堆），重复这个过程直到整个序列有序。
堆排序的步骤如下：
1、将待排序序列构造成一个大顶堆（或小顶堆）。
2、将堆顶元素与末尾元素交换。
3、调整剩余元素为大顶堆（或小顶堆）。
4、重复步骤2和3，直到整个序列有序。
实现代码如下：
public static void main(String[] args) {
int[] arr = {4, 6, 8, 5, 9};
heapSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void heapSort(int[] arr) {
int temp;
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
for (int j = arr.length - 1; j > 0; j--) {
temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
adjustHeap(arr, 0, j);
}
}
public static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
输出结果
4 5 6 8 9
7. 计数排序（Counting Sort）
计数排序（Counting Sort）是一种线性时间复杂度的排序算法，适用于待排序的数值在一定范围内的情况。其原理是通过统计每个数值出现的次数，然后根据次数将数值放到相应的位置上。
实现代码如下：
public static void main(String[] args) {
int[] arr = {4, 2, 2, 8, 3, 3, 1};
countingSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void countingSort(int[] arr) {
int max = getMax(arr);
int min = getMin(arr);
int range = max - min + 1;
int[] count = new int[range];
int[] output = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
count[arr[i] - min]++;
}
for (int i = 1; i < count.length; i++) {
count[i] += count[i - 1];
}
for (int i = arr.length - 1; i >= 0; i--) {
output[count[arr[i] - min] - 1] = arr[i];
count[arr[i] - min]--;
}
for (int i = 0; i < arr.length; i++) {
arr[i] = output[i];
}
}
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
public static int getMin(int[] arr) {
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
输出结果
1 2 2 3 3 4 8
8. 桶排序（Bucket Sort）
桶排序（Bucket Sort）是一种分布式排序算法，它将待排序的数据分到有限数量的桶里。每个桶再分别进行排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。最后把各个桶中的数据依次取出，就得到了排序好的序列。
原理：
1、确定一个合适的桶的数量，使得数据能够均匀分布到各个桶中。
2、对每个桶中的数据进行排序。
3、将各个桶中的数据依次取出，得到排序好的序列。
实现代码如下：
public static void main(String[] args) {
int[] arr = {4, 2, 2, 8, 3, 3, 1};
bucketSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void bucketSort(int[] arr) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int i : arr) {
max = Math.max(max, i);
min = Math.min(min, i);
}
int bucketNum = max - min + 1;
List<List<Integer>> bucketList = new ArrayList<List<Integer>>(bucketNum);
for (int i = 0; i < bucketNum; i++) {
bucketList.add(new ArrayList<Integer>());
}
for (int i : arr) {
bucketList.get(i - min).add(i);
}
int index = 0;
for (List<Integer> bucket : bucketList) {
Collections.sort(bucket);
for (int i : bucket) {
arr[index++] = i;
}
}
}
输出结果
1 2 2 3 3 4 8
9. 基数排序（Radix Sort）
基数排序（Radix Sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。具体步骤如下：
1、找到待排序的数组中的最大值，确定最大值的位数。
2、从最低位开始，依次对每一位进行计数排序。
3、将排序好的数按照当前位数合并到一起。
4、重复步骤2和3，直到最高位。
实现代码如下：
public static void main(String[] args) {
int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
radixSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void radixSort(int[] arr) {
int max = getMax(arr);
for (int exp = 1; max / exp > 0; exp *= 10) {
countSort(arr, exp);
}
}
private static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
private static void countSort(int[] arr, int exp) {
int n = arr.length;
int[] output = new int[n];
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]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
输出结果
2 24 45 66 75 90 170 802
10. 希尔排序（Shell Sort）
希尔排序（Shell Sort）是一种基于插入排序的算法，通过将待排序的元素按照一定的间隔分组，对每组进行插入排序，然后逐渐减小间隔，直到间隔为1，此时整个数组已经基本有序，再进行一次插入排序即可。
希尔排序的原理如下：
1、初始化一个间隔gap，通常取数组长度的一半。
2、从gap开始，依次向后遍历数组，将当前元素与它前面的gap个元素进行比较，如果当前元素小于前面的gap个元素中的某个元素，则将这个元素向后移动gap个位置，直到找到合适的位置插入当前元素。
3、当gap减小到1时，说明数组已经基本有序，此时再进行一次插入排序。
4、重复步骤2和3，直到gap为0。
实现代码如下：
public static void main(String[] args) {
int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
shellSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void shellSort(int[] arr) {
int gap = arr.length / 2;
while (gap > 0) {
for (int i = gap; i < arr.length; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
gap /= 2;
}
}
输出结果
1 2 3 4 5 6 7 8 9