JAVA数据结构--排序算法
- 排序算法的介绍
- 时间复杂度
- 冒泡排序
- 选择排序
- 插入排序
- 希尔排序
- 快速排序
- 归并排序
- 基数排序(桶排序)
- 各种排序算法的比较
排序算法的介绍
- 内部排序: 指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
- 外部排序法： 数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。
- 常见的排序算法分类(见右图)
时间复杂度
- 事后统计的方法 这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所 得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。
- 事前估算的方法 通过分析某个算法的时间复杂度来判断哪个算法更优.
时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间 就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 T(n)。
- 一般情况下，算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数，用 T(n)表示，若有某个辅 助函数 f(n)，使得当 n 趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称 f(n)是 T(n)的同数量级函数。 记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
- T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的 T(n) 不同，但时间复杂 度相同，都为 O(n²)。
- 计算时间复杂度的方法：
(1)用常数 1 代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
(2)修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
(3)去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)
常见的时间复杂度：
- 常数阶 O(1)
- 对数阶 O(log2n)
- 线性阶 O(n)
- 线性对数阶 O(nlog2n)
- 平方阶 O(n^2)
- 立方阶 O(n^3)
- k 次方阶 O(n^k)
- 指数阶 O(2^n)
冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
优化： 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在 排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排 序写好后，在进行)
package bilibili.sort;
public class BubbleSort {
public static void main(String[] args) {
int[] array = {1,-7,54,23,17,74,8};
BubbleSort bubbleSort = new BubbleSort();
bubbleSort.Sort(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
public void Sort(int[] array){
boolean flag = false;
int tmp = 0;
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
//从小到大排列
if(array[j]>array[j+1]){
flag = true;
tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
}
if(flag == false){
break;
}else {
flag = false;
}
}
}
}选择排序
选择式排序也属于内部排序法，是从将要排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到 排序的目的。
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从 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 次，得到一个按排序码从小到大排列的有序序列。
package bilibili.sort;
public class SelectSort {
public static void main(String[] args) {
int[] array = {1, -7, 54, 23, 17, 74, 8};
SelectSort selectSort = new SelectSort();
selectSort.Sort1(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
public void Sort1(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
int inIndex = i;
int min = array[i];
for (int j = i + 1; j < array.length; j++) {
if (array[inIndex] > array[j]) {
inIndex = j;
min = array[j];
}
}
if (inIndex != i) {
//注意顺序
array[inIndex] = array[i];
array[i] = min;
}
}
}
}插入排序
插入式排序属于内部排序法，是对于将要排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有 序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排 序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
package bilibili.sort;
public class InsertSort {
public static void main(String[] args) {
int[] array = {1, -7, 54, 23, 17, 74, 8};
InsertSort insertSort = new InsertSort();
insertSort.Sort2(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
public void Sort2(int[] array) {
for (int i = 1; i < array.length; i++) {
int insertVal = array[i];
int insertIndex = i - 1;
//从小到大排列
//注意变量的使用
while (insertIndex >= 0 && insertVal < array[insertIndex]) {
array[insertIndex + 1] = array[insertIndex];
insertIndex--;
}
//退出循环说明找到了位置
array[insertIndex + 1] = insertVal;
}
}
}希尔排序
希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含 的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
package bilibili.sort;
public class ShellSort {
public static void main(String[] args) {
int[] array = {1, -7, 54, 23, 17, 74, 8};
ShellSort shellSort = new ShellSort();
// shellSort.Sort3(array);
shellSort.Sort4(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
//对有序序列在插入时采用交换法
public void Sort3(int[] array) {
for (int gap = array.length / 2; gap > 0; gap /= 2) {
//gap既是组数，也是步长
for (int i = gap; i < array.length; i++) {
for (int j = i - gap; j >= 0; j -= gap) {
if (array[j] > array[j + gap]) {
int tmp = array[j];
array[j] = array[j + gap];
array[j + gap] = tmp;
}
}
}
}
}
//对有序序列在插入时采用直接插入法
public void Sort4(int[] array){
for(int gap = array.length/2;gap>0;gap/=2){
for(int i = gap;i< array.length;i++){
int j =i;
int tmp = array[j];
while (j-gap>=0&&tmp<array[j-gap]){
array[j] = array[j-gap];
j -= gap;
}
array[j] = tmp;
}
}
}
}快速排序
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两 部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排 序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
分析如下：
方法其实很简单:分别从初始序列“6 1 2 7 9 3 4 5 1 0 8”两端开始“探测”。先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换它们。这里可以用两个变量i和j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边(即i=1)，指向数字6。让哨兵j指向序列的最右边(即j=10)，指向数字8。
首先哨兵j开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵j先出动，这一点非常重要(自己想一想为什么)。哨兵j一步一步地向左挪动(即j–)，直到找到个小于6的数停下来。接下来哨兵i再一步一步向右挪动(即i++)，直到找到一个大于6的数停下来。最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。
现在交换哨兵 i 和哨兵 j 所指向的元素的值。交换之后的序列如下。
6 1 2 5 9 3 4 7 10 8
到此，第一次交换结束。接下来哨兵 j 继续向左挪动（再次友情提醒，每次必须是哨兵j 先出发）。他发现了 4（比基准数 6 要小，满足要求）之后停了下来。哨兵 i 也继续向右挪动，他发现了 9（比基准数 6 要大，满足要求）之后停了下来。此时再次进行交换，交换之
后的序列如下。
3 1 2 5 4 6 9 7 10 8
到此第一轮“探测”真正结束。此时以基准数 6 为分界点，6 左边的数都小于等于 6，6
右边的数都大于等于 6。回顾一下刚才的过程，其实哨兵 j 的使命就是要找小于基准数的数，
而哨兵 i 的使命就是要找大于基准数的数，直到 i 和 j 碰头为止。
OK，解释完毕。现在基准数 6 已经归位，它正好处在序列的第 6 位。此时我们已经将
原来的序列，以 6 为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“9 7 10 8”。接下来还需要分别处理这两个序列，因为 6 左边和右边的序列目前都还是很混
乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理 6 左边和右
边的序列即可。现在先来处理 6 左边的序列吧。左边的序列是“3 1 2 5 4”。也是照猫画虎同样的做法！调整完毕之后的序列的顺序应该是：
2 1 3 5 4
OK，现在 3 已经归位。接下来需要处理 3 左边的序列“2 1”和右边的序列“5 4”。对
序列“2 1”以 2 为基准数进行调整，处理完毕之后的序列为“1 2”，到此 2 已经归位。序列
“1”只有一个数，也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕，得到
的序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下。
1 2 3 4 5 6 9 7 10 8
对于序列“9 7 10 8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会
得到这样的序列：
1 2 3 4 5 6 7 8 9 10
到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这
一轮的基准数归位，直到所有的数都归位为止，排序就结束了。
package bilibili.sort;
public class QuickSort {
public static void main(String[] args) {
int[] array = {1,-7,54,23,17,74,8};
QuickSort quickSort = new QuickSort();
quickSort.Sort5(array,0, array.length-1);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
public void Sort5(int[] array,int left,int right){
if(left>right){
return;
}
int l =left;
int r = right;
int tmp = array[left];
while(l<r){
while (l<r&&array[r]>=tmp){
r--;
}
while(l<r&&array[l]<=tmp){
l++;
}
if(l<r){
int t = array[r];
array[r] = array[l];
array[l] = t;
}
}
if(l == r){
array[left] = array[l];
array[l] = tmp;
}
Sort5(array,left,r-1);
Sort5(array,r+1,right);
}
}归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer） 策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修 补"在一起，即分而治之)。
算法原理：
这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分
序列逐层拆分如下
然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并，创建一个大序列，序列长度为两个小序列长度之和，p1、p2指针分别指向两个小序列的第一个元素，p指向大序列的第一个元素
比较p1、p2指向的元素，4小于5，将4填入p指向的元素，p、p1往右移一位
此时，序列1已经没有元素，将序列2的元素依次填入大序列中
序列8和1，序列7和2，序列6和3，用同样的方式填入新的序列
接着，以4、5为序列1，1、8为序列2，继续进行合并
创建一个序列长度为4的大序列，p1指向序列1的第一个元素4，p2指向序列2的第一个元素1，p指向大序列的第一个元素
4和1比较，4大于1，1填入p指向的元素，p、p2往右移一位
4和8比较，4小于8，4填入p指向的元素，p、p1往右移一位
5和8比较，5小于8，5填入p指向的元素，p、p1往右移一位
自此，序列1已经没有元素，将序列2的元素依次填入大序列中
序列2、7和序列3、6以同样的方式合并成新的序列
最后，将序列1、4、5、8和序列2、3、6、7以同样的方式继续合并成新的序列
package bilibili.sort;
public class MergetSort {
public static void main(String[] args) {
int[] array = {1, -7, 54, 23, 17, 74, 8};
int[] tmp = new int[array.length];
MergetSort mergetSort = new MergetSort();
mergetSort.Sort6(array,0,6,tmp);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
//将数组进行分组
public void Sort6(int[] arr,int left,int right,int[] tmp){
if(left<right){
int mid = (left+right)/2;
Sort6(arr,left,mid,tmp);//左递归
Sort6(arr,mid+1,right,tmp);//右递归
Merge(arr,left,mid,right,tmp);//将各个小组排序
}
}
public void Merge(int[] arr,int left,int mid,int right,int[] tmp){
int i = left;
int j = mid+1;
int t = 0;
while(i<=mid&&j<=right){
if(arr[i]<arr[j]){
tmp[t] = arr[i];
i++;
t++;
}else if(arr[i]>arr[j]){
tmp[t] = arr[j];
j++;
t++;
}
}
//如果左边有剩余
while(i<=mid){
tmp[t] = arr[i];
t++;
i++;
}
while(j<=right){
tmp[t++] = arr[j++];
}
int tmpLeft = left;
t = 0;
while (tmpLeft<=right){
arr[tmpLeft++] = tmp[t++];
}
}
}基数排序(桶排序)
) 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或 bin sort，顾 名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
2) 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
3) 基数排序(Radix Sort)是桶排序的扩展
4) 基数排序是 1887 年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个 位数分别比较
将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序：
package bilibili.sort;
public class RadixSort {
public static void main(String[] args) {
int[] array = {1, 54, 23, 17, 74, 8};
RadixSort radixSort = new RadixSort();
radixSort.Sort7(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
public void Sort7(int[] array) {
//定义一个二维数组，包含10个一维数组，每个一维数组代表一个桶
int[][] buket = new int[10][array.length];
int[] BuketCount = new int[10];//表示每个桶中进入的数据
//求出最大值
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
int maxLength = (max + "").length();
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
for (int j = 0; j < array.length; j++) {
int m = array[j] / n % 10;
buket[m][BuketCount[m]] = array[j];
BuketCount[m]++;
}//第一轮放入结束
//开始取出
int index = 0;
for (int a = 0; a < 10; a++) {
if (BuketCount[a] != 0) {
for (int l = 0; l < BuketCount[a]; l++) {
array[index++] = buket[a][l];
}
}
BuketCount[a] = 0;
}
}
}
}1) 基数排序是对传统桶排序的扩展，速度很快.
2) 基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
3) 基数排序时稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些 记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且 r[i]在 r[j]之前，而在排序后的序列中，r[i]仍在 r[j]之前， 则称这种排序算法是稳定的；否则称为不稳定的]
各种排序算法的比较
相关术语解释：
- 稳定：如果 a 原本在 b 前面，而 a=b，排序之后 a 仍然在 b 的前面；
- 不稳定：如果 a 原本在 b 的前面，而 a=b，排序之后 a 可能会出现在 b 的后面；
- 内排序：所有排序操作都在内存中完成；
- 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
- 时间复杂度： 一个算法执行所耗费的时间。
- 空间复杂度：运行完一个程序所需内存的大小。
- n: 数据规模 8) k: “桶”的个数
- In-place: 不占用额外内存
- Out-place: 占用额外内存
