目录
(一) 冒泡排序 Dubble Sort
1.原理
让相邻的两个元素进行比较, 看是否满足大小关系, 如果不满足则交换位置, 每一次冒泡会让一个元素放到属于它的位置, 然后进行n轮冒泡, 即完成冒泡排序.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端.
2.代码实现
public class BubbleSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
for (int i = 0; i < n; i++) {
// 退出冒泡的标志
boolean flag = false;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j].compareTo(arr[j + 1]) > 0) {
E temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
// 内层循环存在数据交换
flag = true;
}
}
// 当内层循环不再进行数据交换时, 退出冒泡
if (!flag) {
break;
}
}
}
}
3.时间复杂度分析
- | 时间复杂度 | 分析 |
---|---|---|
最好情况 | O(n) | 当排序数组是有序时, 那么冒泡排序只会执行一次内层循环, 因此时间复杂度为 O(n) |
最坏情况 | O(n2) | 当排序数组是逆序时, 插入排序的内循环和外循环都会执行n次, 因此时间复杂度为 O(n2) |
平均情况 | O(n2) | 冒泡排序平均时间复杂度为 O(n2) |
(二) 选择排序 Selection Sort
1.原理
第一次从待排序的数据元素中选出最小(或最大)的一个元素, 存放在序列的起始位置, 然后再从剩余的未排序元素中寻找到最小(大)元素, 然后放到已排序的序列的末尾. 以此类推, 直到全部待排序的数据元素的个数为零.
2.代码实现
public class SelectionSort<E extends Comparable<E>> implements Sort<E>{
/**
* 选择排序
*
* @param arr
* @param n
*/
@Override
public void sort(E[] arr, int n) {
for (int i = 0; i < n; i++) {
// 寻找[i, n) 区间里的最小值
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[minIndex].compareTo(arr[j]) > 0) {
minIndex = j;
}
}
// 交换当前索引i 与 最小索引minIndex 的值
E temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
3.时间复杂度分析
选择排序算法中, 数组无论是否有序, 每一对元素之间一定会进行一次比较, 因此选择排序算法的时间复杂度为 O(n2), 但是选择排序只需要交换n-1次元素,是交换次数最少的排序算法.
(三) 插入排序 Insertion Sort
1.原理
插入排序, 一般也被称为直接插入排序. 将一个记录有序插入到已经排好序的有序表中, 在有序插入的过程中等到一个新的有序序列(默认将序列的第一个数据看成是一个有序的子序列).
2.代码实现
public class InsertionSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
for (int i = 1; i < n; i++) {
E e = arr[i];
// j保存元素e应该插入的位置
int j;
// 寻找元素arr[i]合适的插入位置
for (j = i; j > 0 && arr[j - 1].compareTo(e) > 0; j--) {
arr[j] = arr[j - 1];
}
arr[j] = e;
}
}
}
3.时间复杂度分析
- | 时间复杂度 | 分析 |
---|---|---|
最好情况 | O(n) | 当排序数组是有序时, 那么插入排序不会执行内层循环, 因此时间复杂度为 O(n) |
最坏情况 | O(n2) | 当排序数组是逆序时, 插入排序的内循环和外循环都会执行n次, 因此时间复杂度为 O(n2) |
平均情况 | O(n2) | 往一个有序数组插入一个元素的平均时间复杂度为O(n), 那么进行了n次操作, 所以平均时间复杂度为O(n2) |
插入排序在插入元素找到合适的位置时, 会提前终止内层循环. 因此数据有序程度越高, 插入排序越高效.
(四) 希尔排序 Shell Sort
1.原理
在上面的插入排序算法的分析中, 数据有序程度越高、数据个数越少, 插入排序越高效. 设想, 可不可先对原始数据进行预处理(粗调), 先让数据变得更有序些, 使得插入排序更高效呢? 于是提出了希尔排序算法
希尔排序算法: 是插入排序的一种又称“缩小增量排序”, 是直接插入排序算法的一种更高效的改进版本.
希尔排序是把数组按下标的一定增量分组, 对每组使用直接插入排序算法排序, 使得每组中的元素有序(预处理), 随着增量逐渐减少, 每组包含的元素越来越多, 当增量减至1时, 整个数组元素恰被分成一组, 算法便终止.
在本文实现的希尔算法中增量的初始化为数组长度的一半(gap = length / 2), 之后增量递减为原来的一半, 直至递减至1
2.代码实现
public class ShellSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
n = arr.length;
// 初始化希尔增量为数组长度的一半, 之后增量递减为原来的一半, 直至递减至1 4 2 1
for (int gap = n / 2; gap > 0; gap = gap / 2) {
// 对gap索引后的元素按 各个分组进行插入排序,
for (int i = gap; i < n; i++) {
E e = arr[i];
// j保存元素e应该插入的位置
int j;
// 寻找元素arr[i]合适的插入位置(组内元素两两相隔gap)
for (j = i; j >= gap && arr[j-gap].compareTo(e) > 0; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = e;
}
}
}
}
3.时间复杂度分析
希尔排序的时间复杂度和增量序列是相关的, 直至今日, 有些增量序列的时间复杂还没有被证明出来, 在本文中使用的增量序列的最坏时间复杂度有可能为O(n2), 在一些给定的增量序列中
如: Hibbard增量(2k - 1)和Sedgewick增量(9 * 4k - 9 * 2k + 1), 最坏的时间复杂度分别是 O(n(3/2)) 和 O(n(4/3))
但即使如此, 希尔排序算法也远比之前介绍的算法快很多, 希尔排序是中等大小规模数据排序的最优选择.
(五) 归并排序 Merge Sort
1.原理
分治法(Divide and Conquer): 字面上的解释是“分而治之”, 就是把一个复杂的问题分成两个或更多的相同或相似的子问题, 再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解, 原问题的解即子问题的解的合并
- 分: 将问题分解为规模更小的子问题
- 治: 将这些规模更小的子问题逐个击破(递归解决)
- 合: 将已解决的子问题合并,最终原问题的解
归并排序(Merge Sort): 是建立在归并操作上的一种有效的排序算法, 该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并, 得到完全有序的序列; 即先使每个子序列有序, 再使子序列段间有序. 若将两个有序表合并成一个有序表, 称为二路归并. 归并排序是一种稳定的排序方法。
- 分: 将数据中的元素一个一个单独分开
- 治: 一个一个元素(子序列)就是有序的数据
- 合: 再将已有序的子序列数据合并, 得到完全有序的序列
2.代码实现
public class MergeSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
mergeSort(arr, 0, n - 1);
}
/**
* 递归使用归并排序, 对arr[l...r]的范围进行排序
*
* @param arr
* @param l
* @param r
*/
private void mergeSort(E arr[], int l, int r) {
if (l >= r) {
return;
}
int mid = (l + r) / 2;
mergeSort(arr, l, mid);
mergeSort(arr, mid + 1, r);
// 归并过程保证了arr[l, mid] 和 arr[mid+1, r] 是有序的, 只有在arr[mid] 比 arr[mid + 1] 大时, 才需要归并操作
if (arr[mid].compareTo(arr[mid + 1]) > 0) {
merge(arr, l, mid, r);
}
}
/**
* 将arr[l, mid] 和 arr[mid+1, r] 两部分进行归并
*
* @param arr
* @param l
* @param mid
* @param r
*/
@SuppressWarnings("all")
private void merge(E[] arr, int l, int mid, int r) {
// 临时数组: 复制arr[l, r]数组
E[] temp = (E[]) new Comparable[r - l + 1];
for (int i = l; i <= r; i++) {
temp[i - l] = arr[i];
}
// 初始化, i指向左半部分的起始索引位置l; j指向右半部分起始索引位置mid+1;
for (int i = l, j = mid + 1, k = l; k <= r; k++) {
if (i > mid) {
// 左半部分的元素全部排序完毕, 按顺序添加(修改)右半部分的元素
arr[k] = temp[j - l];
j++;
} else if (j > r) {
// 右半部分的元素全部排序完毕, 按顺序添加(修改)左半部分的元素
arr[k] = temp[i - l];
i++;
} else if (temp[i - l].compareTo(temp[j - l]) < 0) {
// 左半部分所指元素 > 右半部分所指元素
arr[k] = temp[i - l];
i++;
} else {
// 左半部分所指元素 <= 右半部分所指元素
arr[k] = temp[j - l];
j++;
}
}
}
}
3.时间复杂度分析
归并排序算法的时间复杂度分两部分讨论:
- 数据分解时间: 数据中的元素按二分法一个一个单独分开, 最终形成一颗二叉树, 根据二叉树递归的时间复杂度与树的高度h有关, 根据树的高度h与数据n之间的关系, 可知: h = O ( l o g 2 ( n + 1 ) ) = O ( l o g n ) h = O(log_2(n+1)) = O(logn) h=O(log2(n+1))=O(logn)
- 子序列数据合并时间: 在递归树的每一层,都要处理n个数据的“归并(合并)问题”: merge()操作, 时间复杂度为 O(n)
因此, 归并排序算法的时间复杂度为 O(n) * O(logn) = O(nlogn)
(六) 二、三路快速排序 Quick Sort
1.原理
快速排序(Quick Sort): 是对冒泡排序的一种改进, 该算法也采用分治法实现的. 它的基本思想是: 通过一趟排序将要排序的数据分割成独立的两部分, 其中一部分的所有数据都比另外一部分的所有数据都要小, 然后再按此方法对这两部分数据分别进行快速排序, 整个排序过程可以递归进行, 以此达到整个数据变成有序序列.
总而言之, 快速排序分为三步:
- 在数据中选一个基准数(参照数): 通常为数据第一个元素
- 将数据中小于等于基准数的元素放置基准数的左边, 大于基准数的元素放置基准数的右边(Partition操作)
- 分别对基准数的左右边数据重复(递归)执行上两步操作, 直至基准数的左右子集只有一个元素, 即排序完成
Partition操作图解:
l、r、i: 数组左右端点索引 arr[l, r], i 当前访问的索引
referenceElement: 基准数(参照数), 初始化为数组第一个元素arr[l]
partitionIndex: 分割(分界)点索引, 也是基准数最后所在的索引, 初始化值为l.
-
开始满足: arr[l+1, partitionIndex] <= referenceElement < arr[partitionIndex + 1, i -1]
-
Partition操作
- 当前的访问的元素大于基准数, 即 arr[i] > referenceElement, 无需其他操作, 跳过循环 i++(自动融合到蓝色区域)
- 当前的访问的元素小于等于基准数, 即 arr[i] <= referenceElement
- 当前的访问的元素大于基准数, 即 arr[i] > referenceElement, 无需其他操作, 跳过循环 i++(自动融合到蓝色区域)
-
最终满足: arr[l, partitionIndex-1] <= referenceElement < arr[partitionIndex + 1, r]
2.最简化的快速排序代码实现
/**
* 快速排序
*
* @author Administrator
*/
public class QuickSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
quickSort(arr, 0, n - 1);
}
// 对arr[l...r]部分进行快速排序
private void quickSort(E[] arr, int l, int r) {
if (l >= r) {
return;
}
int partitionIndex = partition(arr, l, r);
quickSort(arr, l, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, r);
}
// 返回partitionIndex, 使得arr[l, partitionIndex - 1] < arr[partitionIndex] < arr[partitionIndex + 1, r]
private int partition(E[] arr, int l, int r) {
// 分割(分界)点索引: 初始化值为数组头索引l
int partitionIndex = l;
// 基准(参照)元素: 默认数组第一个元素 arr[l]
E referenceElement = arr[l];
for (int i = l + 1; i <= r; i++) {
// 当前访问的元素小于等于基准(参照)元素
if (arr[i].compareTo(referenceElement) <= 0) {
partitionIndex++;
swap(arr, i, partitionIndex);
}
}
swap(arr, l, partitionIndex);
return partitionIndex;
}
// 交换函数
private void swap(E[] arr, int i, int j) {
E temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
在此代码实现的快速排序算法中, 会将数组按 分割(分界)点索引 一分为二(两个子集), 直至子集只包含一个元素, 最终形成一颗二叉树. 但与归并排序的 二分法 形成二叉树的方式不一样(logn的深度).
因此二叉树的高度与每次一分为二时的分割(分界)点索引有关. 在数组近乎有序的情况下, 形成的二叉树的深度无限接近数组元素个数n, 二叉树退化成链表, 如图:
由此, 引出 随机化快速排序法: 随机在数组 arr[l…r] 的范围中, 选择一个数值作为基准(参照)元素, 使得二叉树退化成链表的概率是极低的
优化 partition(arr, l, r) 方法
private int partition(E[] arr, int l, int r) {
int partitionIndex = l;
// 随机在arr[l...r]的范围中, 选择一个数值作为基准(参照)元素
swap(arr, l, (int) (Math.random() * (r - l + 1)) + l);
E referenceElement = arr[l];
for (int i = l + 1; i <= r; i++) {
if (arr[i].compareTo(referenceElement) < 0) {
partitionIndex++;
swap(arr, i, partitionIndex);
}
}
swap(arr, l, partitionIndex);
return partitionIndex;
}
我们实现的快速排序算法, 会将等于基准数的元素放进绿色区域. 当使用该算法排序一个重复元素较多的数据时, 会使得绿色区域长度远远大于蓝色区域, 从而导致分成的二叉树极度不平衡
因此我们需要对等于基准数的元素单独处理: 双路快速排序、三路快速排序*
3.双路快速排序代码实现
- 将小于基准数的元素放入数组左端, 将大于基准数的元素放入数组右端, 将等于基准数的元素分别放入数组两端
2.循环遍历白色部分数据(i++, j–), 直到符合 arr[i] > referenceElement 且 arr[j] < referenceElement
public class QuickSort2Way<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
quickSort2Way(arr, 0, n - 1);
}
/**
* 递归使用快速排序,对arr[l...r]的范围进行排序
*
* @param arr
* @param l
* @param r
*/
private void quickSort2Way(E[] arr, int l, int r) {
if (l >= r) {
return;
}
int partitionIndex = partition(arr, l, r);
quickSort2Way(arr, l, partitionIndex - 1);
quickSort2Way(arr, partitionIndex + 1, r);
}
/**
* 双路快速排序的partition: 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
*
* @param arr
* @param l
* @param r
* @return
*/
private int partition(E[] arr, int l, int r) {
// 随机在arr[l...r]的范围中, 选择一个数值作为基准数
swap(arr, l, (int) (Math.random() * (r - l + 1)) + l);
// 基准数
E referenceElement = arr[l];
int i = l + 1;
int j = r;
while (true) {
// 对白色部分数组从左到右寻找第一个大于基准数的元素
while (i <= r && arr[i].compareTo(referenceElement) < 0) {
i++;
}
// 对白色部分数组从右到左寻找第一个小于基准数的元素
while (j >= l + 1 && arr[j].compareTo(referenceElement) > 0) {
j--;
}
if (i > j) {
break;
}
swap(arr, i, j);
i++;
j--;
}
swap(arr, l, j);
return j;
}
private void swap(E[] arr, int i, int j) {
E temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
4.三路快速排序代码实现
-
三路快排是将数组分成了小于基准数,等于基准数,大于基准数的三个部分
-
当前的访问的元素小于基准数, 即 arr[i] < referenceElement
-
当前的访问的元素大于基准数, 即 arr[i] > referenceElement
-
当前的访问的元素等于基准数, 即 arr[i] = referenceElement
-
最终满足: arr[l, lt-1] < referenceElement && arr[lt, gt-1] == referenceElements &&
arr[gt, r] > referenceElement
public class QuickSort3Way<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
quickSort3Way(arr, 0, n - 1);
}
private void quickSort3Way(E[] arr, int l, int r) {
if (l >= r) {
return;
}
// ****************** Partition操作 ******************
swap(arr, l, (int) (Math.random() * (r - l + 1)) + l);
E referenceElement = arr[l];
int lt = l, i = l + 1, gt = r + 1;
while (i < gt) {
if (arr[i].compareTo(referenceElement) < 0) {
// 当前的访问的元素小于基准数
swap(arr, lt + 1, i);
lt++;
i++;
} else if (arr[i].compareTo(referenceElement) > 0) {
// 当前的访问的元素大于基准数
swap(arr, gt - 1, i);
gt--;
} else {
// 当前的访问的元素等于基准数
i++;
}
}
swap(arr, l, lt);
// ***************************************************
quickSort3Way(arr, l, lt - 1);
quickSort3Way(arr, gt, r);
}
private void swap(E[] arr, int i, int j) {
E temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
5. 时间复杂度分析
快速排序算法的时间复杂度分两部分讨论:
- 数据分解的时间: 数据中的元素递归按基准数分成两部分, 最终形成一颗二叉树. 最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况下二叉树会退化成链表 O(n) 的时间复杂度. 但随机化基准数和二、三路快速排序都是为了让形成二叉树的尽量平衡, 达到 O(logn) 的时间复杂度.
- Partition操作: 每次Partition操作操作从数组两头交替搜索arr[l, r], 直到 l >= r, 因此其时间复杂度是O(n)
因此, 归并排序算法的平均时间复杂度为 O(n) * O(logn) = O(nlogn)
注: 当使用基本快速排序,因为用到递归,方法进栈出栈,当数据量达到一定数目的时候会出现堆栈溢出异常java.lang.StackOverflowError
(七) 堆排序 Heap Sort
1.原理
是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
因此得先学习堆这种数据结构, 可以参考博主另一篇文章: 数据结构之二叉堆
堆排序的实现思路分为三部分:
- Heapify堆化: 将排序数组构建成一个最大堆, 此时最大的元素在堆顶
- 重建堆: 将堆顶最大元素与数组的末尾元素交换且忽略最大元素, 此时再对堆顶元素执行siftDown()操作, 使其剩余n-1个元素继续满足堆的性质
- 递归(循环)的执行第二步骤, 直至整个数组有序
2.代码实现
public class HeapSort<E extends Comparable<E>> implements Sort<E> {
@Override
public void sort(E[] arr, int n) {
// 1. Heapify堆化: 将排序数组构建成一个最大堆, 此时最大的元素在堆顶
for (int i = getParentIndex(n - 1); i >= 0; i--) {
siftDown(arr, n, i);
}
// 2.将堆顶最大元素与数组的末尾元素交换且忽略最大元素, 此时再对堆顶元素执行siftDown()操作, 使其剩余n-1个元素继续满足堆的性质
for (int i = n - 1; i >= 0; i--) {
swap(arr, 0, i);
siftDown(arr, i, 0);
}
}
/**
* 下沉操作
*
* @param arr
* @param n 元素个数
* @param index 下沉索引
*/
private void siftDown(E[] arr, int n, int index) {
// 循环停止条件: 当前索引不存在左孩子索引
while (getLeftChildIndex(index) < n) {
// 初始最大元素索引 为 index的左孩子索引
int maxIndex = getLeftChildIndex(index);
// index右孩子索引存在且右孩子索引元素大于左孩子索引元素
if (maxIndex + 1 < n && arr[maxIndex].compareTo(arr[maxIndex + 1]) < 0) {
maxIndex++;
}
// index元素大于最大元素索引元素
if (arr[index].compareTo(arr[maxIndex]) >= 0) {
break;
}
// 交换元素, 更新index值为maxIndex 继续循环
swap(arr, index, maxIndex);
index = maxIndex;
}
}
/**
* 获取index索引的左孩子节点的索引
*
* @param index
* @return
*/
private int getLeftChildIndex(int index) {
return index * 2 + 1;
}
/**
* 获取index索引的父亲节点的索引
*
* @param index
* @return
*/
private int getParentIndex(int index) {
return (index - 1) / 2;
}
/**
* 交换函数
*
* @param arr
* @param i
* @param j
*/
private void swap(E[] arr, int i, int j) {
E temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
3.时间复杂度分析
堆排序算法的时间复杂度分两部分讨论:
- Heapify堆化时间: O(n)
- 重建堆: 在重建堆的过程中需要遍历数组O(n)时间复杂度, 在每次遍历中执行了siftDown()操作, 根据二叉树的性质可知时间复杂度为 O(logn), 因此重建堆的时间复杂度为 O(nlogn)
总结: 堆排序算法的时间复杂度为 O(n) + O(nlogn) = O(nlogn)