文章目录
- 概述
- 1、冒泡排序（Bubble Sort）
- 1.1 步骤
- 1.2 动图演示
- 1.3 java代码实现
- 2、选择排序（Selection Sort）
- 2.1 步骤
- 2.2 动图演示
- 2.3 java代码实现
- 3、插入排序（Insertion Sort）
- 3.1 步骤
- 3.2 动图演示
- 3.3 java代码实现
- 4、希尔排序（Shell Sort）
- 4.1 步骤
- 4.2 动图演示
- 4.3 java代码实现
- 5、快速排序（Quick Sort）
- 5.1 步骤
- 5.2 动图演示
- 5.3 java代码实现
- 6、归并排序（Merge Sort）
- 6.1 步骤
- 6.2 动图演示
- 6.3 java代码实现
- 7、堆排序（Heap Sort）
- 7.1 步骤
- 7.2 动图演示
- 7.3 java代码实现
- 8、计数排序（Counting Sort）
- 8.1 步骤
- 8.2 动图演示
- 8.3 java代码实现
- 9、基数排序（Radix Sort）
- 9.1 步骤
- 9.2 动图演示
- 9.3 java代码实现
- 10、桶排序（Bucket Sort）
- 10.1 步骤
- 10.2 图片演示
- 10.3 java代码实现
概述
-
排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
-
我们通常所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。
-
算法复杂度
1、冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序也是通过遍历比较左右值得大小，例如排升序即左值大于右值交换，最后最大值即排到最右边。
1.1 步骤
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
1.2 动图演示
1.3 java代码实现
public class MaoPaoPX {
public static void main(String[] args) {
int []arr= {3,2,8,4,7};//创建数组
System.out.println("排序前");
showArr(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]) {
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("排序后");
showArr(arr);
}
//打印方法
private static void showArr(int []arr) {
//增强for循环打印
for(int a:arr) {
System.out.print(a+"\t");
}
System.out.println();
}
}
2、选择排序（Selection Sort）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
2.1 步骤
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1…n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
2.2 动图演示
2.3 java代码实现
public class SortDemo {
public static void main(String[] args) {
int[] arr = new int[] { 5, 3, 6, 2, 10, 2, 1 };
selectSort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i; // 用来记录最小值的索引位置，默认值为i
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
}
}
// 交换当前索引 i 和最小值索引 minIndex 两处的值
if (i != minIndex) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
// 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
}
}
}
3、插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
3.1 步骤
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
3.2 动图演示
3.3 java代码实现
package com.test.insertsort;
/*
* 插入排序算法：
* 1、以数组的某一位作为分隔位，比如index=1，假设左面的都是有序的.
*
* 2、将index位的数据拿出来，放到临时变量里，这时index位置就空出来了.
*
* 3、从leftindex=index-1开始将左面的数据与当前index位的数据（即temp）进行比较，如果array[leftindex]>temp,
* 则将array[leftindex]后移一位，即array[leftindex+1]=array[leftindex],此时leftindex就空出来了.
*
* 4、再用index-2(即leftindex=leftindex-1)位的数据和temp比，重复步骤3，
* 直到找到<=temp的数据或者比到了最左面（说明temp最小），停止比较，将temp放在当前空的位置上.
*
* 5、index向后挪1，即index=index+1，temp=array[index],重复步骤2-4，直到index=array.length,排序结束，
* 此时数组中的数据即为从小到大的顺序.
*
*
*/
public class InsertSort {
private int[] array;
private int length;
public InsertSort(int[] array){
this.array = array;
this.length = array.length;
}
public void display(){
for(int a: array){
System.out.print(a+" ");
}
System.out.println();
}
/*
* 插入排序方法
*/
public void doInsertSort(){
for(int index = 1; index<length; index++){//外层向右的index，即作为比较对象的数据的index
int temp = array[index];//用作比较的数据
int leftindex = index-1;
while(leftindex>=0 && array[leftindex]>temp){//当比到最左边或者遇到比temp小的数据时，结束循环
array[leftindex+1] = array[leftindex];
leftindex--;
}
array[leftindex+1] = temp;//把temp放到空位上
}
}
public static void main(String[] args){
int[] array = {38,65,97,76,13,27,49};
InsertSort is = new InsertSort(array);
System.out.println("排序前的数据为：");
is.display();
is.doInsertSort();
System.out.println("排序后的数据为：");
is.display();
}
}
4、希尔排序（Shell Sort）
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
4.1 步骤
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.2 动图演示
4.3 java代码实现
public class ShellSort {
public static void main(String[] args) {
//定义数组
int[] arr = {99, 55, 2, 3, 9, 10, 22, 34, 67, 89, 69, 92, 101, 102};
//增量
int gap = arr.length;
//排序
sort(arr, gap);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void sort(int[] arr, int gap) {
//确定新一轮分组的增量
gap = gap / 2;
//对数组进行分组
for (int i = 0; i < gap; i++) {
for (int j = i + gap; j < arr.length; j += gap) {
//获取当前元素，然后在本组内部向前比较并排序
int current = arr[j];
for (int k = j - gap; k >= i; k -= gap) {
if (arr[k] > current) {
//插入
arr[k + gap] = arr[k];
arr[k] = current;
}
}
}
}
if (gap > 1) {
sort(arr, gap);
}
}
}
5、快速排序（Quick Sort）
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
5.1 步骤
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
5.2 动图演示
5.3 java代码实现
public class QuickSort {
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public void quickSort(int[] arr, int start, int end) {
if (start >= end)
return;
int k = arr[start];
int i = start, j = end;
while (i != j) {
while (i < j && arr[j] >= k)
--j;
swap(arr, i, j);
while (i < j && arr[i] <= k)
++i;
swap(arr, i, j);
}
quickSort(arr, start, i - 1);
quickSort(arr, i + 1, end);
}
public static void main(String[] args) {
int[] arr = {5, 2, 6, 9, 1, 3, 4, 8, 7, 10};
new QuickSort().quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}
6、归并排序（Merge Sort）
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
6.1 步骤
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
6.2 动图演示
6.3 java代码实现
public class Main {
public static void main(String[] args) {
int[] arr = {11,44,23,67,88,65,34,48,9,12};
int[] tmp = new int[arr.length]; //新建一个临时数组存放
mergeSort(arr,0,arr.length-1,tmp);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
public static void merge(int[] arr,int low,int mid,int high,int[] tmp){
int i = 0;
int j = low,k = mid+1; //左边序列和右边序列起始索引
while(j <= mid && k <= high){
if(arr[j] < arr[k]){
tmp[i++] = arr[j++];
}else{
tmp[i++] = arr[k++];
}
}
//若左边序列还有剩余，则将其全部拷贝进tmp[]中
while(j <= mid){
tmp[i++] = arr[j++];
}
while(k <= high){
tmp[i++] = arr[k++];
}
for(int t=0;t<i;t++){
arr[low+t] = tmp[t];
}
}
public static void mergeSort(int[] arr,int low,int high,int[] tmp){
if(low<high){
int mid = (low+high)/2;
mergeSort(arr,low,mid,tmp); //对左边序列进行归并排序
mergeSort(arr,mid+1,high,tmp); //对右边序列进行归并排序
merge(arr,low,mid,high,tmp); //合并两个有序序列
}
}
}
7、堆排序（Heap Sort）
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
7.1 步骤
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
7.2 动图演示
7.3 java代码实现
public class HeapSort {
public static void heapSort(int[] arr) {
if (arr == null || arr.length <= 1) return;
// 建堆。
buildHeap(arr);
int len = arr.length;
while (len > 1) {
// 把堆顶和最后一个元素交换。
swap(arr, 0, len - 1);
// 交换完之后，逻辑上去掉最后一个元素。
len--;
// 重新调整堆的顺序。
heapfy(arr, 0 , len);
// 把每一趟排序的结果也输出一下。
print(arr);
}
}
private static void buildHeap(int[] arr) {
// 最后一个非叶子结点：2i + 1 >= arr.length --> i >= (arr.length - 1) / 2
for (int i = (arr.length - 1) / 2 - 1; i >= 0; i--) {
heapfy(arr, i, arr.length);
}
}
// 调整堆的顺序，保持大顶堆。
private static void heapfy(int[] arr, int i, int len) {
while (true) {
int maxPostion = i;
int leftChild = 2 * i + 1; // 左孩子索引。
int rightChild = 2 * i + 2; // 右孩子索引。
// 若左孩子大于最大值，则更新最大值。
if (leftChild < len && arr[leftChild] > arr[maxPostion]) {
maxPostion = leftChild;
}
// 若右孩子大于最大值，则更新最大值。
if (rightChild < len && arr[rightChild] > arr[maxPostion]) {
maxPostion = rightChild;
}
if (maxPostion == i) {
break; // 若已经是大顶堆了，则退出循环。
} else {
swap(arr, i, maxPostion); // 若不是大顶堆，则交换位置。
i = maxPostion;
}
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] =temp;
}
public static void main(String[] args) {
int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};
System.out.print("排序前: ");
print(arr);
heapSort(arr);
System.out.print("排序后: ");
print(arr);
}
// 打印数组
public static void print(int[] arr) {
if (arr == null) return;
for(int i : arr) {
System.out.print(i + " ");
}
System.out.println();
}
}
/*
排序前: 6 9 1 4 5 8 7 0 2 3
8 6 7 4 5 1 3 0 2 9
7 6 3 4 5 1 2 0 8 9
6 5 3 4 0 1 2 7 8 9
5 4 3 2 0 1 6 7 8 9
4 2 3 1 0 5 6 7 8 9
3 2 0 1 4 5 6 7 8 9
2 1 0 3 4 5 6 7 8 9
1 0 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
排序后: 0 1 2 3 4 5 6 7 8 9
*/
8、计数排序（Counting Sort）
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
8.1 步骤
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
8.2 动图演示
8.3 java代码实现
/**
* 计数排序
*/
public class CountSort {
/**
* <p>计数排序</p>
* <p>时间复杂度为O(3n+k)</p>
* <p>空间复杂度为O(k)</p>
*
* @param src 待排序数组
* @return 排好序的数组
*/
public static int[] countSort(int[] src) {
// 数组中的最小值
int min = src[0];
// 数组中的最大值
int max = src[0];
for (int value : src) {
if (value < min) {
min = value;
} else if (value > max) {
max = value;
}
}
// 数组中的数据范围
int range = max - min + 1;
// count[i]表示数组src中数据min + i的个数
int[] count = new int[range];
for (int value : src) {
count[value - min]++;
}
// 累计，使得count[i]保存src中小于等于min + i的数据的个数
for (int i = 1; i < range; i++) {
count[i] += count[i - 1];
}
// 结果数组
int[] res = new int[src.length];
// 倒序遍历原数组，保持排序的稳定性
for (int i = src.length - 1; i >= 0; i--) {
// 获取数据在count数组中的索引
int index = src[i] - min;
// 个数减1
count[index]--;
// 数据src[i]排序后的索引是count[index]
res[count[index]] = src[i];
}
return res;
}
}
9、基数排序（Radix Sort）
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
9.1 步骤
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
9.2 动图演示
9.3 java代码实现
public static void radixSort(int[] arr) {
//1. 得到数组中最大的数的位数
int max = arr[0]; //假设第一数就是最大数
for(int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//得到最大数是几位数
int maxLength = (max + "").length();
//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
//说明
//1. 二维数组包含10个一维数组
//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
//3. 基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
//这里我们使用循环将代码处理
for(int i = 0 , n = 1; i < maxLength; i++, n *= 10) {
//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
for(int j = 0; j < arr.length; j++) {
//取出每个元素的对应位的值
int digitOfElement = arr[j] / n % 10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
int index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k = 0; k < bucketElementCounts.length; k++) {
//如果桶中，有数据，我们才放入到原数组
if(bucketElementCounts[k] != 0) {
//循环该桶即第k个桶(即第k个一维数组), 放入
for(int l = 0; l < bucketElementCounts[k]; l++) {
//取出元素放入到arr
arr[index++] = bucket[k][l];
}
}
//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
bucketElementCounts[k] = 0;
}
}
10、桶排序（Bucket Sort）
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
10.1 步骤
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序； - 从不是空的桶里把排好序的数据拼接起来。
10.2 图片演示
10.3 java代码实现
import java.util.Arrays;
public class bucketSortTest {
public static void bucketSort(int[] num) {
// 遍历原始数组，找到数组中的最大值
int max = num[0];
for (int i = 0; i < num.length; i++) {
if (num[i] > max) {
max = num[i];
}
}
// 创建一个下标为原始数组中最大值的桶数组,该桶数组的下标代表元素，该数组下标所对应的值代表这个值出现的次数
int[] bucketArray = new int[max + 1];
// 再次遍历原始数组，得到原数组中存在的各个元素，以及出现的次数
for (int i = 0; i < num.length; i++) {
bucketArray[num[i]]++;
}
// 遍历桶数组,外层循环从桶的第一位开始（即下表为零）；内层循环遍历桶数组中下标为i的值出现的次数
int index = 0;
for (int i = 0; i < bucketArray.length; i++) {
for (int j = 0; j < bucketArray[i]; j++) {
num[index++] = i;
}
}
}
public static void main(String[] args) {
int[] num=new int[] { 2,5,6,8,5,2,9,6};
bucketSort(num);
System.out.println(Arrays.toString(num));
}
}
