十大经典算法 java 实现过程
1.冒泡排序
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来
说并没有什么太大作用。
1.1 算法步骤
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
1.2 代码实现
public static int[] bubbleSort(int[] sourceArray){
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 1; i < arr.length; i++) {//外层控制比较的躺数
// 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
boolean flag = true;
for (int j = 0; j < arr.length - i; j++) {//内存控制每趟需要排序多少次
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = false;
}
}
if (flag) {
break;
}
}
return arr;
}2.选择排序
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
2.1 算法步骤
1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。
2.2 代码实现
public static int[] selectionSort(int[] sourceArray){
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 总共要经过 N-1 轮比较
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i 每次都从i+1开始比较 每次比较个数将逐步减少
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}3.插入排序
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
3.1 算法步骤
1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
3.2 代码实现
public static int[] insertSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
for (int i = 1; i < arr.length; i++) { //控制比较的躺数
// 记录要插入的数据
int tmp = arr[i];
// 从已经排序的序列最右边开始比较，找到比其小的数
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1]; //已排序的序列下标向后移
j--; //已经排序的序列下标左移
}
// 存在比其小的数，插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}4.希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
4.1 算法步骤
1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2. 按增量序列个数 k，对序列进行 k 趟排序；
3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.2 代码实现
public static int[] shellSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int length = arr.length;
int temp;
/**
* <p>
* step = length / 2 根据length分为若干份 step /= 2 增量每次从减半 只要最终增加为1时及终止
* </p>
*/
for (int step = length / 2; step >= 1; step /= 2) {
for (int i = step; i < length; i++) {
temp = arr[i]; //记录交换值
int j = i - step;
while (j >= 0 && arr[j] > temp) {
arr[j + step] = arr[j]; //交换
j -= step;//每次减增量及每次都是与同一组的数据进行比较
}
arr[j + step] = temp;//交换值插入
}
}
return arr;
}5.归并排序
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：
- 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
- 自下而上的迭代；
5.1 算法步骤
-
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
-
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
-
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
-
重复步骤 3 直到某一指针达到序列尾；
-
将另一序列剩下的所有元素直接复制到合并序列尾。
5.2 代码实现
public static int[] mergeSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
if (arr.length < 2) { //因为需要分组 所以最少需要两个元素小于两个元素则不可再分 直接return
return arr;
}
int middle = (int) Math.floor(arr.length / 2);//分组后向下取整
int[] left = Arrays.copyOfRange(arr, 0, middle);//取组左
int[] right = Arrays.copyOfRange(arr, middle, arr.length);//取右
return merge(mergeSort(left), mergeSort(right));//递归两侧直到不可在分隔 --> length < 2
}
protected static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];//定义合并后的容器为：left + right
int i = 0;
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i++] = left[0];//比较后放入队列
left = Arrays.copyOfRange(left, 1, left.length);//弹出取出的值
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
// 处理只有一边大只有 或 只有一边有值情况
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}6.快速排序
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。
6.1 算法步骤
-
从数列中挑出一个元素，称为 "基准"（pivot）;
-
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
-
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
6.2 代码实现
private static int[] quick(int[] arr, int left, int right) {
if (left < right) {//当 left >= right 是就是正确的基准位置
int partitionIndex = partition(arr, left, right);
quick(arr, left, partitionIndex - 1);
quick(arr, partitionIndex + 1, right);
}
return arr;
}
private static int partition(int[] arr, int left, int right) {
// 基准数据
int tmp = arr[left];
while (left < right) {
// 当队尾的元素大于等于基准数据时,向前挪动high指针
while (left < right && arr[right] >= tmp) {
right--;
}
// 如果队尾元素小于tmp了,需要将其赋值给low
arr[left] = arr[right];
// 当队首元素小于等于tmp时,向前挪动low指针
while (left < right && arr[left] <= tmp) {
left++;
}
// 当队首元素大于tmp时,需要将其赋值给high
arr[right] = arr[left];
}
// 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
// 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
arr[left] = tmp;
return left; // 返回tmp的正确位置
}7. 堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
- 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
- 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
堆排序的平均时间复杂度为 Ο(nlogn)。
7.1 算法步骤
-
创建一个堆 H[0……n-1]；
-
把堆首（最大值）和堆尾互换；
-
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
-
重复步骤 2，直到堆的尺寸为 1。
节点规则：
父结点索引：(i-1)/2（这里计算机中的除以2，省略掉小数）
左孩子索引：2*i+1
右孩子索引：2*i+2
即可得出规则公式：
大根堆：arr(i)>arr(2*i+1) && arr(i)>arr(2*i+2)
小根堆：arr(i)<arr(2*i+1) && arr(i)<arr(2*i+2)
7.2 代码实现
public static int[] heapSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
//初始化构造大根堆
heapInsert(arr);
int size = arr.length;
while (size > 1) {
//固定最大值
swap(arr, 0, size - 1);
size--;
//构造剩余数据的大根堆
heapify(arr, 0, size);
}
return arr;
}
public static void heapInsert(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int currentIndex = i;//当前插入的索引
int fatherIndex = (currentIndex - 1) / 2;//父结点索引
//如果当前插入的值大于其父结点的值,则交换值 并且将索引指向父结点然后继续和上面的父结点值比较，直到不大于父结点，则退出循环
while (arr[currentIndex] > arr[fatherIndex]) {
swap(arr, currentIndex, fatherIndex);//交换当前结点与父结点的值
currentIndex = fatherIndex;//将当前索引指向父索引
fatherIndex = (currentIndex - 1) / 2; //重新计算当前索引的父索引
}
}
}
public static void heapify(int[] arr, int index, int size) {
int left = 2 * index + 1; //左孩子
int right = 2 * index + 2; //右孩子
while (left < size) {
int largestIndex;
//判断孩子中较大的值的索引（要确保右孩子在size范围之内）
if (arr[left] < arr[right] && right < size) {
largestIndex = right;
} else {
largestIndex = left;
}
//比较父结点的值与孩子中较大的值，并确定最大值的索引
if (arr[index] > arr[largestIndex]) {
largestIndex = index;
}
//如果父结点索引是最大值的索引，那已经是大根堆了，则退出循环
if (index == largestIndex) {
break;
}
//父结点不是最大值，与孩子中较大的值交换
swap(arr, largestIndex, index);
index = largestIndex;//将索引指向孩子中较大的值的索引
//重新计算交换之后的孩子的索引
left = 2 * index + 1;
right = 2 * index + 2;
}
}
//交换数组中两个元素的值
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}8. 计数排序
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数
8.1 算法步骤
1.找出待排序的数组中最大和最小的元素
2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
8.2 代码实现
public static int[] countingSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxValue = getMaxValue(arr); //获取最大值
return counting(arr, maxValue);
}
public static int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
public static int[] counting(int[] arr, int maxValue) {
int bucketLen = maxValue + 1;//最大下标位
int[] bucket = new int[bucketLen];
for (int value : arr) {
//计数 及 index 为key -> 需要排序的数据值 value为v -> 此值有多少个 则在填充时需要占多少个索引位
bucket[value]++;
}
int sortedIndex = 0;
for (int j = 0; j < bucketLen; j++) {
while (bucket[j] > 0) { //将计数结果赋值到原始数组
arr[sortedIndex++] = j;
bucket[j]--; //计数 -1
}
}
return arr;
}9. 桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。
9.1 算法步骤
1. 设置一个定量的数组当作空桶子；
2. 寻访序列，并且把记录一个一个放到对应的桶子去；
3. 对每个不是空的桶子进行排序。
4. 从不是空的桶子里把项目再放回原来的序列中。
9.2 代码实现
public static int[] bucketSort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return bucket(arr, 5);//初始化桶容量为5
}
public static int[] bucket(int[] arr, int bucketSize) {
if (arr.length == 0) {
return arr;
}
int minValue = arr[0];
int maxValue = arr[0];
for (int value : arr) { //获取最大值和最小值
if (value < minValue) {
minValue = value;
} else if (value > maxValue) {
maxValue = value;
}
}
int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;//（最大值-最小值）/每个桶的容量 = 每个桶的容量
int[][] buckets = new int[bucketCount][0];
// 利用映射函数将数据分配到各个桶中
for (int i = 0; i < arr.length; i++) {
int index = (int) Math.floor((arr[i] - minValue) / bucketSize);//（当前值 - 最小值）/每个桶的容量 = values具体应该入的哪个桶
buckets[index] = arrAppend(buckets[index], arr[i]);//分配到具体的桶
}
int arrIndex = 0;
for (int[] bucket : buckets) {//遍历每个桶
// for (int i = buckets.length -1 ; i >=0 ; i--) { //倒序需要将桶反方向取出
// int[] bucket = buckets[i];
if (bucket.length <= 0) {
continue;
}
// 对每个桶进行排序，这里使用了插入排序（插入排序时间复杂度为O(n^2) 少量数据会因为较低循环次数而降低）
bucket = insertSort(bucket);
for (int value : bucket) {//排序后因为桶是有序的 每个桶也是有序的 所以直接赋值到数组中就OK
arr[arrIndex++] = value;
}
}
return arr;
}
public static int[] arrAppend(int[] arr, int value) {
//由于不确定每个桶到底会有多少value 所以每次桶进入一次 length+1 从0开始 并赋值到扩容的index -> arr的最后一位
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}10. 基数排序
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
10.1 算法步骤
1. 首先确定待排序序列 arr 中最大的元素，得出元素的位数 N，位数 N 决定了基数排序需要进行 N 轮；
2. 附设一个二维数组 bucket 作为桶（如 bucket[m][n] 表示第 m 个桶的第 n 个元素）。由于一位数有 10 种可能（0~9），因此需要10 个桶；又因为arr 中可能所有元素某一位完全相同即都在一个桶中，因此每个桶最小存储能力要等于 arr.length。故 bucket 需要初始化为 new int[10][arr.length]；
3. 由于需要对每个桶多次存取数据，因此还需附设一个一维数组 bucketCount 作为每个桶的计数器（如 bucketCount[2] 的值代表着第三个桶当前的计数值）；
4. 第一轮开始，遍历待排序序列 arr ，求得每个元素的个位数，然后将元素放入到其个位数对应的桶中。元素放置完毕之后，再从桶中按照次序读取数据覆盖到 arr ；
5. 第二轮开始，首先清空桶中的元素，然后遍历最新的 arr，求得每个元素的十位数，然后将元素放入到其十位数对应的桶中。元素放置完毕后，再从桶中按照次序读取数据覆盖 arr ；
6. 循环执行步骤 5，直到总计执行了 N 轮，然后从桶中读出数据到 arr 中，此时 arr 中便是最终排序结果。
10.2 代码实现
public static int[] radixSort(int sourceArray[]) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int max = arr[0]; // 用于记录原始数组中最大的数，初始化为 arr[0]
/* 获取数组中最大的数 */
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
int maxDigit = (max + "").length();// 获取最大的数的位数
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
/**
* <p>
* 使用二维数组表示桶counter 以及桶中的数据 bucket
* 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
* 并不知道桶中是否会有符合的数据 默认为0 入桶后桶扩容
* </p>
*/
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
//counter[bucket] = arrAppend(counter[bucket], arr[j]);//扩容赋值
counter[bucket] = Arrays.copyOf(counter[bucket], counter[bucket].length + 1);
counter[bucket][counter[bucket].length - 1] = arr[j];
}
int pos = 0; //将每个桶中的有序列 顺序填充数组
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}总结：
基数排序 vs 计数排序 vs 桶排序
这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
- 基数排序：根据键值的每位数字来分配桶；
- 计数排序：每个桶只存储单一键值；
- 桶排序：每个桶存储一定范围的数值；
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
