目录
前言:
- 掌握七大基于比较的排序算法基本原理及实现
- 掌握排序算法的性能分析
- 掌握Java中的常用排序方法
1.概念
1.1 排序
排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
平时的上下文中,如果提到排序,通常指的是排升序(非降序)。
通常意义上的排序,都是指的是原地排序。
1.2稳定性(重要)
两个相等的数据,如果经过排序后,排序算法能保证其相对位置不发生变化,则我们称该算法是具备稳定性的排序算法。
2.七大基于比较的排序-总览
3.插入排序
3.1直接插入排序-原理
整个区间被分为:
- 有序区间
- 无序区间
每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入:
3.2 实现
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) { //无序区间
// 有序区间: [0, i)
// 无序区间: [i, array.length)
int v = array[i]; // 无序区间的第一个数,保存下来(哨兵法)
int j = i - 1;
// 不写 array[j] == v 是保证排序的稳定性
//在有序区间中排序
for (; j >= 0 && array[j] > v; j--) {
array[j + 1] = array[j];//数往前移
}
//发现移不动时,把v放到对应位置
array[j + 1] = v;
}
}
3.3性能分析
稳定性:稳定
插入排序,初始数据越接近有序,时间效率越高。
4. 希尔排序
4.1原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所有距离为相同记录的分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排好序。
希尔排序实际上就是插入排序的升级版
4.2 代码实现
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
insertSortGap(array, gap);
gap = (gap / 3) + 1; // 或 gap = gap / 2;
}
insertSortGap(array, 1);
}
//插入排序
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int j = i - gap;
for (; j >= 0 && array[j] > v; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = v;
}
}
4.3性能分析
稳定性:不稳定
5.选择排序
5.1直接选择排序原理
每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完 。
5.2 实现
//把大的值都往后面放
public static void selectSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
int max = 0;
//先找出最大的值
for (int j = 1; j < array.length - i; j++) {
if (array[j] > array[max]) {
max = j;
}
}
//把最大的值放到后面
int t = array[max];
array[max] = array[array.length - i - 1];
array[array.length - i - 1] = t;
}
}
5.3 性能分析
稳定:不稳定
int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别,保证 5a 还在 5b 前边
6.堆排序
6.1原理
基本原理也是选择排序,只是不在使用遍历的方式查找无序区间的最大的数,而是通过堆来选择无序区间的最大的数。
注意: 排升序要建大堆;排降序要建小堆。
如图:
6.2 实现
public static void heapSort(int[] array) {
createHeap(array);
for (int i = 0; i < array.length - 1; i++) {
// 交换前
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
swap(array, 0, array.length - i - 1);
// 交换后
// 无序区间: [0, array.length - i - 1)
// 有序区间: [array.length - i - 1, array.length)
// 无序区间长度: array.length - i - 1
shiftDown(array, array.length - i - 1, 0);
}
}
private void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
}
private void createHeap(int[] array) {
for (int i = (array.length - 1) / 2; i >= 0; i--) {
shiftDown(array, array.length, i);
}
}
public static void shiftDown(int[] array, int size, int index) {
int left = 2 * index + 1;
while (left < size) {
int max = left;
int right = 2 * index + 2;
if (right < size) {
if (array[right] > array[left]) {
max = right;
}
}
if (array[index] >= array[max]) {
break;
}
int t = array[index];
array[index] = array[max];
array[max] = t;
index = max;
left = 2 * index + 1;
}
}
6.3性能分析
7.冒泡排序
7.1原理
在无序区间,通过相邻数的比较,将最大的数冒泡到无序区间的最后,持续这个过程,直到数组整体有序。
7.2实现
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean isSorted = true;
for (int j = 0; j < array.length - i - 1; j++) {
// 相等不交换,保证稳定性
if (array[j] > array[j + 1]) {
swap(array, j, j + 1);
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}
7.3性能分析
稳定性:稳定
8.快速排序(重要)
8.1原理-总览
1. 从待排序区间选择一个数,作为基准值(pivot);
2. Partition: 遍历整个待排序区间,将比基准值小的(可以包含相等的)放到基准值的左边,将比基准值大的(可以包含相等的)放到基准值的右边;
3. 采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 == 1,代表已经有序,或者小区间的长度 == 0,代表没有数据。
动画理解:
9月4日
(只介绍)挖坑法:
代码实现:
public static void quickSort(int[] array) {
quickSortInternal(array, 0, array.length - 1);
}
// [left, right] 为待排序区间
private static void quickSortInternal(int[] array, int left, int right) {
if (left == right) {
return;
}
if (left > right) {
return;
}
// 最简单的选择基准值的方式,选择 array[left] 作为基准值
// pivotIndex 代表基准值最终停留的下标
int pivotIndex = partition(array, left, right);
// [left, pivotIndex - 1] 都是小于等于基准值的
// [pivotIndex + 1, right] 都是大于等于基准值的
quickSortInternal(array, left, pivotIndex - 1);
quickSortInternal(array, pivotIndex + 1, right);
}
private static int partition(int[] array, int left, int right) {
int i = left;
int j = right;
int pivot = array[left];
while (i < j) {
while (i < j && array[j] >= pivot) {
j--;
}
array[i] = array[j];
while (i < j && array[i] <= pivot) {
i++;
}
array[j] = array[i];
}
array[i] = pivot;
return i;
}
8.2性能分析
稳定性:不稳定
8.3原理-基准值的选择
- 1. 选择边上(左或者右)
- 2. 随机选择
- 3. 几数取中(例如三数取中):array[left], array[mid], array[right] 大小是中间的为基准值
9.归并排序(重要)
9.1原理
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
如图:
9.2代码实现
public static void mergeSort(int[] a){
mergeSortInternal(a,0,a.length-1);
}
//分割操作,递归的方法
private static void mergeSortInternal(int[] a,int low,int high){
if(low>=high){
return ;
}
int mid=(low+high)/2;
mergeSortInternal(a,low,mid);
mergeSortInternal(a,mid+1,high);
merge(a,low,mid,high);
}
//归并操作
private static void merge(int[] a,int low,int mid,int high){
int i = low;
int j = mid+1;
int length = high-low+1;
int k =0;
int[] extra = new int[length];//创建临时数组
while(i<=mid&&j<=high){
if(a[i]<=a[j]){
extra[k++] = a[i++];
}else {
extra[k++] = a[j++];
}
}
//发现有的放完了,有的没有放完到临时数组中去
while(i<=mid){
extra[k++] = a[i++];
}
while(j<=high){
extra[k++] = a[j++];
}
//赋值到原来的数组中,加上low是为了防止被覆盖
for(int t=0;t<length;t++){
a[low+t] = extra[t];
}
}
9.3性能分析
稳定性:稳定
9.5海量数据的排序问题
外部排序:排序过程需要在磁盘等外部存储进行的排序
前提:内存只有 1G,需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下,所以需要外部排序,而归并排序是最常用的外部排序
1. 先把文件切分成 200 份,每个 512 M
2. 分别对 512 M 排序,因为内存已经可以放的下,所以任意排序方式都可以
3. 进行 200 路归并,同时对 200 份有序文件做归并过程,最终结果就有序了
10.排序总结