排序也称排序算法(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
说明:
代码实现:
//选择排序 时间复杂度为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]
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的值放在调整后的位置
}
}