排序
排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。排序的分类：
- 内部排序:
指将需要处理的所有数据都加载到内部存储器中进行排序。 - 外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行
排序。
冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。
思路分析：原始数组：3, 9, -1, 10, 20
第一趟排序
(1) 3, 9, -1, 10, 20 // 如果相邻的元素逆序就交换
(2) 3, -1, 9, 10, 20
(3) 3, -1, 9, 10, 20
(4) 3, -1, 9, 10, 20
第二趟排序
(1) -1, 3, 9, 10, 20 //交换
(2) -1, 3, 9, 10, 20
(3) -1, 3, 9, 10, 20
第三趟排序
(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20
第四趟排序
(1) -1, 3, 9, 10, 20
小结冒泡排序规则：
(1) 一共进行 数组的大小-1 次 大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化
代码实现：
//冒泡排序 时间复杂度为O(n^2)
public static void bubbleSort(int[] arr) {
int temp = 0;//临时变量
boolean flag = false;//标识变量 表示没发生交换
for (int i = 0; i < arr.length - 1; i++) {//i表示当前是第i+1趟排序
//第i+1趟排序就是把第i+1大的数放在倒数第i+1的位置
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if (!flag) {
break;//在一趟排序中一次交换也没发生 则说明数组已经有序 break即可
} else {
flag = false;//重置flag 进行下一次标识
}
}
}
选择排序
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。
它的基本思想是：第一次从arr[0] 到arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]到arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]到arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]到arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
思路分析：
原始的数组 ： 101, 34, 119, 1
第一轮排序 : 1, 34, 119, 101
第二轮排序 : 1, 34, 119, 101
第三轮排序 : 1, 34, 101, 119
说明：
- 选择排序一共有 数组大小 - 1 轮排序
- 每1轮排序，又是一个循环, 循环的规则(见代码)
2.1先假定当前这个数是最小数
2.2 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
2.3 当遍历到数组的最后时，就得到本轮最小数和下标
2.4 交换 [见代码]
代码实现：
//选择排序 时间复杂度为O(n^2)
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;//第一轮默认最小值下标是0
int min = arr[i];//第一轮默认最小值为第一个数
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) { //如果按从大到小排序则改成min < arr[j]即可
min = arr[j];//重置最小值
minIndex = j;//重置最小值下标
}
}
//交换 优化：如果最小值没变化就不必交换
if (minIndex != i) {
arr[minIndex] = arr[i]; //arr[0]=101->arr[3]=101
arr[i] = min;//arr[0]=101->arr[0]=1
}
}
}
插入排序（简单插入）
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
思路分析（图示）：
代码实现：
//插入排序
public static void insertSort(int[] arr) {
int insertVal = 0;//待插入的数
int insertIndex = 0;
for (int i = 1; i < arr.length; i++) {
insertVal = arr[i];//待插入的数
insertIndex = (i) - 1;//带插入位置的索引 插入到前一位 所以-1
//说明：1、insertIndex >= 0 保证在给insertIndex找插入位置时不越界
// 2、insertVal < arr[insertIndex] 说明还没找到插入位置
// 3、需要将arr[insertIndex]后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}//退出循环时 表示已经找到要插入的位置
if (insertIndex + 1 != i) {//优化：如果找的的要插入位置就是其本身所在位置 则无需再赋值
arr[insertIndex + 1] = insertVal;
}
// System.out.println("第" + i + "轮插入排序后：" + Arrays.toString(arr));
}
}
希尔排序
简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响.
因此出现了希尔排序：希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
思路分析：（图示）
代码实现：
1、对有序序列在插入时采用交换法
//希尔排序-----交换法
public static void shellSort(int[] arr) {
int temp = 0;
int count = 0;
//增量gap 逐渐缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//遍历各组中所有元素 共gap组 步长gap
for (int i = gap; i < arr.length; i++) {
for (int j = i - gap; j >= 0; j -= gap) {
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
// System.out.println("第" + (++count) + "轮希尔排序的后：" + Arrays.toString(arr));
}
}
2、对有序序列在插入时采用移动法（效率更高）
//希尔排序-----移位法（对交换法进行优化 速度快了）
public static void shellSort2(int[] arr) {
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素开始 逐个对其所在组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
//直接插入排序
int j = i;//保存待插入位置的下标 类似insertIndex
int temp = arr[j];//保存要插入的数据 类似insertVal
if (arr[j]<arr[j-gap]) {
while (j-gap>=0&&temp<arr[j-gap]) {
//移动
arr[j]=arr[j-gap];
j-=gap;
}
//退出while循环后就表示找到了插入的位置
arr[j]=temp;
}
}
}
}
快速排序
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
示意图：
基准数可以选取中间数 也可以选取第一个数 选哪个数都可以 随意
韩老师的快排没大听懂 下面的代码是听罗召勇老师讲的 感觉更好理解
代码实现：
public static void quickSort(int[] arr, int start, int end) {
if (start<end) {
//将数组中的第0个数字 设置为基准数
int stard = arr[start];
//记录需要排序的下标
int low = start;
int high = end;
while (low < high) {
//右边的数比基准数大 则向左移动high指针
while (low < high && arr[high] >= stard) {
high--;
}//退出此while循环说明当前a[high]<stard
arr[low] = arr[high];//用high位的数覆盖low位的数
//左边的数比基准数小 则向右移动low指针
while (low < high && arr[low] <= stard) {
low++;
}//退出此while循环说明当前a[low]>stard
arr[high] = arr[low];
}
//low和high指针相遇时 将基准数赋给此下标处
arr[low] = stard;
//System.out.println("第一次快速排序后的数组为：" + Arrays.toString(arr));
//递归
//处理所有比基准数小的数字
quickSort(arr,start,low);
//处理所有比基准数大的数字
quickSort(arr,low+1,end);
}
}
归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
基本思想图示：
代码实现：
//归并排序
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
//向左递归分解
mergeSort(arr, 0, mid, temp);
//向右递归分解
mergeSort(arr, mid + 1, right, temp);
//合并
merge(arr, left, right, mid, temp);
}
}
//合并
/**
* @param arr 需要排序的原始数组
* @param left 左边有序序列的初始索引
* @param right 右边有序序列的初始索引
* @param mid 中间索引
* @param temp 做中转的数组
* @return void
* @author lylicoo
* @date 2020/6/22 20:07
*/
public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
//
int i = left;//初始化i，左边有序序列的初始索引
int j = mid + 1;//初始化k，右边有序序列的初始索引
int t = 0;//指向temp数组的当前索引
//1、先把左右两边数组按照规则填充到temp数组
// 直到左右两边的有序序列有一边处理完毕
while (i <= mid && j <= right) {
//若左边序列的当前元素<=右边序列的当前元素
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t++;
i++;
} else {
temp[t] = arr[j];
t++;
j++;
}
}//两种情况退出当前while循环
//2、把有剩余元素的一边的数据依次全部填充到temp
while (i <= mid) {
temp[t] = arr[i];
t++;
i++;
}
while (j <= right) {
temp[t] = arr[j];
t++;
j++;
}
//3、将temp数组的元素拷贝到arr 注意：并不是每次都拷贝所有
t = 0;
int tempLeft = left;
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
t++;
tempLeft++;
}
}
基数排序
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用，是桶排序的扩展。
基本思想：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
举例图示：将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序。
代码实现：
//基数排序
public static void radixSort(int[] arr) {
//得到数组中的最大数的位数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxLength = (max + "").length();
//定义一个二维数组 表示10个桶 每个桶又是一个一维数组
//说明：二维数组包含十个一位数组 为了防止放入数据时桶大小不够 所以每个桶的大小设为arr.length
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[index] = bucket[k][l];
index++;
}
}
bucketElementCounts[k] = 0;//桶要清空
}
System.out.println("第"+(i+1)+"轮排序后的数组："+Arrays.toString(arr));
}
}
基数排序的说明:
1、基数排序是对传统桶排序的扩展，速度很快.
2、基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
3、基数排序是稳定的。
注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
4、有负数的数组，一般不用基数排序来进行排序
堆排序
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
一般升序采用大顶堆，降序采用小顶堆 。
堆排序思路分析：（见ppt图解）
1).将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
代码实现：升序
package com.datastructures.tree.heap;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
public class HeapSort {
public static void main(String[] args) {
//对该数组进行升序排列
//int[] arr = {4, 6, 8, 5, 9,0,-1,22,-88};
//heapSort(arr);
//测试堆排序的速度 随机给80000个数 ---
int[] arr=new int[800000];
for (int i=0;i<800000;i++){
arr[i]=(int)(Math.random()*800000);//[0,800000)
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间是："+date1Str);
heapSort(arr);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间是："+date2Str);
}
//编写方法实现堆排序
public static void heapSort(int[] arr) {
int temp = 0;
//1)将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// System.out.println("调整后的堆为：" + Arrays.toString(arr));
//2)将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
//3)重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
for (int j = arr.length - 1; j > 0; j--) {
//交换
temp = arr[j];
arr[j] = arr[0];//调整好的堆 最大值肯定在数组的第一位
arr[0] = temp;
adjustHeap(arr, 0, j);
}
// System.out.println("堆排序的结果：" + Arrays.toString(arr));
}
//将一个数组（二叉树）调整成一个大顶堆
/**
* 功能：将以i为父节点的树 调整成大顶堆
*
* @param arr 待调整的数组
* @param i i表示非叶子节点在数组中的索引
* @param length 对length个数据进行调整 没调整一次length-1
*/
public static void adjustHeap(int arr[], int i, int length) {
int temp = arr[i];//保存当前元素的值
//调整
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {//左子节点的值小于右子节点的值
k++;
}
if (arr[k] > temp) {
//把两者中较大的值赋给当前节点arr[i]
arr[i] = arr[k];
i = k;//i指向k继续循环比较
} else {
break;
}
}//for循环结束后 以i为父节点的树的最大值已经放在了最顶部
arr[i] = temp;//将temp的值放在调整后的位置
}
}
常用排序算法对比
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
