几大排序算法的Java实现
Java实现几大常用的排序算法
1，简单插入排序
主要思路将num[i]插入到一个已经排好的数组num[0…i-1]中 ，因为涉及到数据的查找和移动，最坏情况下平均时间复杂度为o(n^2).
public static void insertion_sorting(int[] nums){
int temp;
int j,i;
for (i = 1;i < nums.length; ++i){
if (nums[i] < nums[i-1]){
temp = nums[i];
for (j = i-1;j >= 0&&nums[j]>temp; --j)nums[j+1] = nums[j];
nums[j+1] = temp;
}
}
}
折半插入排序
插入排序的主要思想就是在一个有序的序列中不停的查找，移动。因此查找过程可以用折半查找代替。
public static void BInsertion_Sorting(int[] nums){
int temp;
for (int i = 1;i < nums.length; ++i) {
if (nums[i] < nums[i - 1]) {
temp = nums[i];
int low = 0, height = i - 1;
while (low <= height) {
int m = (low + height) / 2;
if (nums[m] <= temp) low = m + 1;
else height = m - 1;
}
for (int j = i - 1; j >= height + 1; --j) nums[j + 1] = nums[j];
nums[height + 1] = temp;
}
}
}
引入折半查找的方法后虽然可以减少查找的步骤，但是无法减少数据移动的步骤，因此折半插入排序时间复杂度依然是o(n^2)
2,希尔排序
希尔排序是一种改进的插入排序，因为排序时数组都有序度越高，插入排序的时间复杂度就越低，如果排序前数据已经是有序的，那么插入排序的时间复杂度就是o(n),如果是最坏情况，插入排序的时间复杂度就是o(n^2).
基于这个特点可以先将数组按照一定的规则分成几个部分，先对这几个部分进行初步的插入排序，然后再对整个部分进行插入排序，因为局部已经做到初步的“有序”，所以可以尽量的减少最后一个插入排序的时间复杂度。而划分部分的方法可以通过设定增量的方式进行。
//希尔排序,先将数组按照增量分成若干个小份，先对小份进行插入排序然后在对整个数组进行插入排序
//增量的选择视数组的情况而定
public static void Shell_sort(int[] nums){
int[] dlta = new int[]{5,3,1}; //增量序列
int temp,k;
for (int i = 0;i<dlta.length;++i){
int dk = dlta[i]; //保存增量
for (int j = dk;j<nums.length;j++){
if (nums[j]<nums[j-dk]){
temp = nums[j];
for (k = j-dk;k>=0&&nums[k]>temp;k-=dk)nums[k+dk] = nums[k];
nums[k+dk] = temp;
}
}
}
}
希尔排序的时间复杂度依赖于增量的选择，大致范围是O（nlogn）～O（n2）。
3，冒泡排序
通过“交换”思想进行的排序，通过相邻数字两两交换的方式将最大/小的数放到 最后，然后将次大/小的数放到第二的位置，以此类推。平均时间复杂度o(n^2).
public static void bubble_sort(int[] nums){
int temp;
for (int i = nums.length-1;i>0;--i){
for (int j = 0;j<i;++j){
if (nums[j]>nums[j+1]){
temp = nums[j+1];
nums[j+1] = nums[j];
nums[j] = temp;
}
}
}
}
4,快速排序
冒泡排序的改进版，通过一趟排序将记录分割成两部分，其中一部分记录的关键子均比另一部分的关键字小，然后将分别对这两部分记录继续排序，直到整个序列有序。
//快速排序
private static int Partition(int[] a,int low,int height){
int pivotkey = a[low];
while (low<height){
while (low<height&&a[height]>=pivotkey)height--;
a[low] = a[height];
while (low<height&&a[low]<=pivotkey)low++;
a[height] = a[low];
}
a[low] = pivotkey;
return low;
}
private static void QSort(int[] nums,int low,int height){
if (low<height){
int m = Partition(nums,low,height);
QSort(nums,low,m-1);
QSort(nums,m+1,height);
}
}
public static void QuickSort(int[] nums){
QSort(nums,0,nums.length-1);
}
首先选取记录中第一个元素作为枢轴，然后将小于它的放在其左边，大于它的放在其右边，然后再分别对两部分递归执行上述过程，直到整个记录有序。
快速排序平均时间复杂度o(nlogn),但在最坏情况下为o(n^2)
5,简单选择排序
主要思路就是将排行第几的数字放在排行第几的位置上，与冒泡排序很像，以及与我经常将他们搞混，但是实质上是有区别的。冒泡排序是在遍历的过程中不停的交换相邻的两个元素，将最大/小的元素移动到数组的最后，选择排序是先将最大/小的元素找出来，然后和对应位置的元素交换，只在每一趟的最后进行一次交换，突出一个"选择"二字。
//选择排序
public static void selection_sort(int[] nums){
int temp;
int i,j;
for (i=0;i<nums.length-1;++i){
int index = i;
for (j=i+1;j<nums.length;++j){
if (nums[i] > nums[j]&&nums[j]<nums[index]){
index = j;
}
}
temp = nums[i];
nums[i] = nums[index];
nums[index] = temp;
}
}
6，堆排序
上面的几种排序算法都是基于一种“比较"的思想，不管是“选择”还是”插入“，都是基于比较结果来进行后续操作，比如甲想要考全班第一，他需要赢过其他所有人，乙想考全班第二，他需要赢过除甲以外的所有人。但是事实上并不用如此，如果甲的成绩比乙高，乙的成绩比丙高，那么自动就可以认为甲的成绩比丙高，必须要再比一次。而堆排序就是基于这种”锦标赛"的思想，建立的。
首先将记录处理成一个堆（关于什么是堆这里不做讨论)，之后堆的根节点就是最大/小的节点，然后将最后的元素跟根节点交换，将其再次处理成堆，循环往复，直到有序。
//堆排序,平均时间复杂度为o(nlog(n)),不推荐在数据数量较少的情况下使用，因为建堆和调整堆很费时间
public static void heapsort(int[] nums){
//将一个无序的数组调整成一个堆
for (int i=nums.length/2;i>=0;--i){
HeapAdjust(nums,i,nums.length);
}
//进行堆排序
for (int i=nums.length-1;i>0;--i){
int temp = nums[0];
nums[0] = nums[i];
nums[i] = temp;
HeapAdjust(nums,0,i);
}
}
//nums[] 保存当前要进行调整的堆，s表示堆的根节点，m表示堆的节点 数量
private static void HeapAdjust(int[] nums,int s, int m){
int temp = nums[s];
for (int i=s*2;i<m-1;i*=2){
if (nums[i] < nums[i + 1])i++;
if (nums[i]<=temp)break;
nums[s] = nums[i];
s = i;
}
nums[s] = temp;
}
平均时间复杂度为o(nlog(n))
7，归并排序
“归并"的含义是将两个或者两个以上的有序表组合成一个新的有序表。首先两两合并，然后合并后的序列在两两合并，直到最后两个大的子序列合并。
//归并排序
private static int[] newNums; //归并排序的辅助空间
public static void mergeSort(int[] nums){
//将辅助空间设定为与待排序列等大，其实不需要等大，在排序 过程中需要多大申请多大就行了，但是我懒省事
newNums = new int[nums.length];
//开始排序
MSort(nums,0,nums.length-1);
}
//
private static void MSort(int[] nums,int s,int t){
if (s != t){
int m = (s+t)/2; //获取数组中间位置
MSort(nums,s,m); //递归调用
MSort(nums,m+1,t); //递归调用
Merge(nums,s,m,t); //排序算法
}
}
private static void Merge(int nums[],int s,int m,int t){ //i开始，m中间，n结尾
//将需要排序的段复制到辅助空间中
for (int i = s;i<=t;++i){
newNums[i] = nums[i];
}
//以类似起扑克的方式将需要排序的段重新排序，并复制到原数组中
int i,j;
int k = s;
for (i = s,j = m+1;i<=m&&j<=t;){
if (newNums[i]>=newNums[j]){
nums[k] = newNums[j];
j++;
k++;
}else {
nums[k] = newNums[i];
i++;
k++;
}
}
if (i > m){
for (int n = j;n<=t;++n){
nums[k] = newNums[n];
k++;
}
}else {
for (int n = i;n<=m;++n){
nums[k] = newNums[n];
k++;
}
}
}
时间复杂度o(nlogn)
8，基数排序
基数排序和前面的排序都不相同，它通过链表的方式实现。首先向记录处理成链表，然后再创建出十个链表，对应’0-9’十个数字，然后获取记录中各数据个位上的数，按照上面创建的链表存入，然后将链表连起来，及将记录按照个位上的数进行了一次初排。之后在获取十位上的数，重复上述操作，知道所有位上的数都检查了一遍。
//基数排序
public static void radixSort(int[] nums){
//创建十个arrayList用于保存中间生成的list
ArrayList<Integer> list_0,list_1,list_2,list_3,list_4, list_5,
list_6,list_7,list_8,list_9;
//保存数组中的最大值
int maxNumber = 0;
//numList用于保存结果列表
ArrayList<Integer> numList = new ArrayList<>();
list_0 = new ArrayList<>();list_1 = new ArrayList<>();list_2 = new ArrayList<>();
list_3 = new ArrayList<>();list_4 = new ArrayList<>();list_5 = new ArrayList<>();
list_6 = new ArrayList<>();list_7 = new ArrayList<>();list_8 = new ArrayList<>();
list_9 = new ArrayList<>();
//查询数组中的最大值，并且将数组处理成静态列表
for (int i=0;i<nums.length;++i){
if (nums[i]>=maxNumber)maxNumber = nums[i];
numList.add(nums[i]);
}
//p用于辅助获取每个位上的数字
int p = 1;
for (;maxNumber>0; maxNumber/=10){
for (int i=0;i<numList.size();++i){
int temp = numList.get(i)/p;
//获得每个位上的数字，并保存到对应的arrayList中
if (temp%10 == 0) list_0.add(numList.get(i));
else if (temp%10 == 1) list_1.add(numList.get(i));
else if (temp%10 == 2) list_2.add(numList.get(i));
else if (temp%10 == 3) list_3.add(numList.get(i));
else if (temp%10 == 4) list_4.add(numList.get(i));
else if (temp%10 == 5) list_5.add(numList.get(i));
else if (temp%10 == 6) list_6.add(numList.get(i));
else if (temp%10 == 7) list_7.add(numList.get(i));
else if (temp%10 == 8) list_8.add(numList.get(i));
else if (temp%10 == 9) list_9.add(numList.get(i));
}
p *= 10;
//清除结果序列，并将初步排列的数字重新添加到结果序列中
numList.clear();
for (int i=0;i<list_0.size();++i)numList.add(list_0.get(i));
for (int i=0;i<list_1.size();++i)numList.add(list_1.get(i));
for (int i=0;i<list_2.size();++i)numList.add(list_2.get(i));
for (int i=0;i<list_3.size();++i)numList.add(list_3.get(i));
for (int i=0;i<list_4.size();++i)numList.add(list_4.get(i));
for (int i=0;i<list_5.size();++i)numList.add(list_5.get(i));
for (int i=0;i<list_6.size();++i)numList.add(list_6.get(i));
for (int i=0;i<list_7.size();++i)numList.add(list_7.get(i));
for (int i=0;i<list_8.size();++i)numList.add(list_8.get(i));
for (int i=0;i<list_9.size();++i)numList.add(list_9.get(i));
list_0.clear();list_1.clear();list_2.clear();list_3.clear();
list_4.clear();list_5.clear();list_6.clear();list_7.clear();
list_8.clear();list_9.clear();
}
//将排完序的序列重新改成数组，并返回
for (int i = 0;i<numList.size();++i){
nums[i] = numList.get(i);
}
}
基数排序的时间复杂度是o(d*n),最优的情况下甚至可以做到线性时间，但是同样具有局限性。毫无疑问这是一种那空间换时间的算法，需要耗费大量的辅助空间。适用于n很大，关键字较小的序列。是想一下，对{1,10000000002}这个序列排序，用普通排序很容易解决，但是用基数排序需要浪费大量的空间和时间。对于小数和负数的处理同样有些复杂。
9，计数排序
计数排序就是首先用记录中的最大值创建一个Count数组，该数组的空间与记录中最大值等大（最理想情况下是申请Max-Min+1个空间），该数组用于存放记录中的数出现了几次。比如说记录中出现了两个5，就在Count[4]的位置记为2。注意，记录中的值与Count数组中的下标一一对应，及关键字值为5就在Count[4]的位置上加一，直到对整个记录遍历了一遍。然后用计数数组Count还原原数组。及如果Count[4]上的值为2，就在结果数组中添加两个5。因为我们遍历Count数组是顺序遍历的，所以原数组就自动排序了。
//计数排序
public static void countingSort(int[] nums){
int maxNum=0,minNum=Integer.MAX_VALUE;
for (int i=0;i<nums.length;++i){
if (nums[i]>=maxNum)maxNum = nums[i];
if (nums[i]<=minNum)minNum = nums[i];
}
int[] newNums = new int[maxNum+1];
for (int i=0;i<nums.length;++i) newNums[nums[i]]++;
int p = 0;
for (int i=0;i<newNums.length;++i){
if (newNums[i]!=0){
for (int m=newNums[i];m>0;--m){
nums[p] = i;
p++;
}
}
}
}
但是第一次看到这个算法时被震撼到了，原来还可以这么简单，而且成功将排序算法的时间复杂度拉到了线性水平o(n+k)。但是后来仔细想想，该方法存在很多局限性，比如要求数组必须是正整数，如果存在负数和小数需要先对数据进行处理。而且和上面同样的问题，如何数组中的最大值和最小值跨度很大，会浪费很多不必要的空间。比如上面的例子对{1,1000000000002}排序，明明只有两个元素却需要至少创建一个1000000000002大小的Count数组。所以只适用于n很大，且关键字大小很集中的记录。