排序算法

最新推荐文章于 2023-02-12 20:42:34 发布

又十七

最新推荐文章于 2023-02-12 20:42:34 发布

阅读量322

点赞数

分类专栏：数据结构与算法文章标签：排序算法数据结构 java

本文链接：https://blog.csdn.net/admin_lian/article/details/105372027

版权

数据结构与算法专栏收录该内容

15 篇文章 0 订阅

订阅专栏

(一) 冒泡排序 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(n²)	当排序数组是逆序时, 插入排序的内循环和外循环都会执行n次, 因此时间复杂度为 O(n²)
平均情况	O(n²)	冒泡排序平均时间复杂度为 O(n²)

(二) 选择排序 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(n²), 但是选择排序只需要交换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(n²)	当排序数组是逆序时, 插入排序的内循环和外循环都会执行n次, 因此时间复杂度为 O(n²)
平均情况	O(n²)	往一个有序数组插入一个元素的平均时间复杂度为O(n), 那么进行了n次操作, 所以平均时间复杂度为O(n²)

插入排序在插入元素找到合适的位置时, 会提前终止内层循环. 因此数据有序程度越高, 插入排序越高效.

(四) 希尔排序 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(n²), 在一些给定的增量序列中

如: Hibbard增量(2^k - 1)和Sedgewick增量(9 * 4^k - 9 * 2^k + 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(log_2(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操作
1. 当前的访问的元素大于基准数, 即 arr[i] > referenceElement, 无需其他操作, 跳过循环 i++(自动融合到蓝色区域)
2. 当前的访问的元素小于等于基准数, 即 arr[i] <= referenceElement
最终满足: 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)

又十七

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法

目录(一) 选择排序 Selection Sort1.原理2.代码实现(一) 选择排序 Selection Sort1.原理第一次从待排序的数据元素中选出最小（或最大）的一个元素, 存放在序列的起始位置, 然后再从剩余的未排序元素中寻找到最小（大）元素, 然后放到已排序的序列的末尾. 以此类推, 直到全部待排序的数据元素的个数为零.2.代码实现public class Selectio...
复制链接

扫一扫