Java排序方法中，分为基于比较的排序方法和非基于比较的排序方法。基于比较的排序方法适用于各类规模的数据，适用范围比较广。非基于比较的排序方法需要占用空间来确定其唯一位置，所以适用范围有限。
不要求稳定，数据规模小，且数据无序的情况下，选择快速排序；要求稳定且数据规模小，数据有序的情况下，选择插入排序，数据无序的情况下，选择归并排序；若数据规模较大，选择快速排序，归并排序，或堆排序。
一. 基于比较的排序方法
1. 冒泡排序
稳定性：稳定
时间复杂度：O(N) --O(N^2)
空间复杂度：O(1)
原理：重复访问一组数列，每次比较相邻的两个元素，然后根据大小进行交换。
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
swap(array, j, j + 1);
flag = true;
}
}
if (!flag) {
break;
}
}
}2. 插入排序
稳定性：稳定
时间复杂度：O(N) --O(N^2) 当数据较为有序时，插入排序的效率较高
空间复杂度：O(1)
原理：把一组数列中的第一个元素看成有序数列，把第二个元素到最后一个元素看成未排序数列，进行扫描，按照顺序向前进行插入，类似抽扑克牌。
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int tmp = array[i];//记录要插入的数据
for (int j = i-1; j >= 0; j--) {//从最右边开始找比其小的数
if(array[j] > tmp) {
array[j+1] = array[j];
}else{
break;
}
}
array[j+1] = tmp;
}
}3. 希尔排序
稳定性：不稳定
时间复杂度：O(N)--O(N^2)
空间复杂度：O(1)
原理: 希尔排序是比插入排序更高效的排序方法，但是是不稳定的。希尔排序先将整个待排序的序列分成若干子序列，然后分别进行插入排序，带整个序列基本有序时，再对所有元素依次进行插入排序。
public static void shellSort(int[] array){
int gap= array.length;
while(gap>1){
gap/=2;
shell(array,gap);
}
}
private static void shell(int[] array, int gap){
for(int i=gap;i< array.length;i++){
int tmp=array[i];
int j=i-gap;
for(;j>=0;j-=gap){
if(array[j]>tmp){
array[j+gap]=array[j];
}else{
break;
}
}
array[i+gap]=tmp;
}
}4.归并排序
稳定性：稳定
时间复杂度：O(n * log(n))
空间复杂度：O(n) 占用辅助空间
原理：归并排序是一种分治法思想的算法应用，设置两个指针，起始位置都位于两个已经排序序列的首位，比较两个指针所指的元素，将相对较小的元素放入合并空间内，并移动指针到下一个位置。
public static void mergeSort(int[] array){
int gap=1;
while(gap<array.length){
for(int i=0;i<array.length;i+=gap*2){
int left=i;
int mid=left+gap;
int right=mid+gap;
if(mid>=array.length){
mid= array.length;
}
if(right>= array.length){
right= array.length;
}
merge(array,left,mid,right);
}
gap*=2;
}
}
private static void merge(int[] array, int left, int mid, int right){
int s1=left;
int e1=mid;
int s2=mid+1;
int e2=right;
int[] tmp=new int[right-left+1];
int k=0;//tmp数组的下标
while(s1<=e1 && s2<=e2){
if(array[s1]<=array[s2]){
tmp[k++]=array[s1++];
}else{
tmp[k++]=array[s2++];
}
}
while(s1<=e1){
tmp[k++]=array[s1++];
}
while(s2<=e2){
tmp[k++]=array[s2++];
}
for(int i=0;i<k;i++){
array[i+left]=tmp[i];
}
}5. 堆排序
稳定性：不稳定
时间复杂度：O(n * log(n))
空间复杂度：O(1)
原理: 堆积是一个类似于完全二叉树的结构，子节点的索引总是小于或大于其父节点。创建大根堆可以用于升序排序，小根堆可以用于降序排序。
public static void heapSort(int[] array){
createBigHeap(array);//创建大根堆
int end= array.length-1;
while(end>0){
swap(array,end,0);//交换堆首和堆尾
shiftDown(array,0,end);//把新的数组顶端数据调整到相应位置
end--;
}
}
private static void createBigHeap(int[] array){
for(int i=(array.length-1-1)/2;i>=0;i--){
shiftDown(array,i,array.length);
}
}
private static void shiftDown(int[] array, int parent, int len){
int child=parent*2+1;
while(child<len){
if(child+1<len && array[child]<array[child+1]){
child++;
}
if(array[child]>array[parent]){
swap(array, child, parent);
parent=child;
child=parent*2+1;
}else{
break;
}
}
}6. 选择排序
稳定性：不稳定
时间复杂度：O(n^2)
空间复杂度：O(1)
原理：在未排序的数组中找到最小或最大的元素，放到序列的起始位置，再从剩余未排序的数组中继续找到最小或最大的元素，放到已排序的序列的尾部。
public static void selectSort(int[] array){
for(int i=0;i< array.length;i++){
int minIndex=i;
for(int j=i+1;j< array.length;j++){
if(array[j]<array[minIndex]){
minIndex=j;
}
}
swap(array,minIndex,i);
}
}7. 快速排序
稳定性：不稳定
时间复杂度：O(n * log(n))--O(n^2)
空间复杂度：O(log(n)) ~ O(n)
原理：快速排序比其他排序方法效率高很多，使用分治法把一个串行分成两个子串行。快速排序有3个版本，基本思路是先从数列中挑一个元素，作为基准，将剩余元素根基准值进行比较，分成两个区域，比较小的放在一边，比较大的放在另一边，基准值此时在中间位置，然后进行递归进行排序。
//Hoare法
private static int partition(int[] array, int left, int right){
int i=left;//记录这个位置
int tmp=array[left];
while(left<right){
while(left<right && array[right]>=tmp){
right--;
}
while(left<right && array[left]<=tmp){
left++;
}
swap(array,left,right);
}
swap(array,left,i);
return left;
}
//挖坑法
private int partition(int[] array, int left, int right){
int tmp=array[left];
while(left<right){
while(left<right && array[right]>=tmp){
right--;
}
array[left]=array[right];
while(left<right && array[left]<=tmp){
left++;
}
array[right]=array[left];
}
array[left]=tmp;
return left;
}
//前后指针法
private static void partition(int[] array, int left, int right){
int prev=left;
int cur=left+1;
while(cur<=right){
if(array[cur]<array[left] && array[++prev]!=array[cur]){
swap(array,cur,prev);
}
cur++;
}
swap(array, prev, left);
return prev;
}
二. 非基于比较的排序方法--计数排序 vs 桶排序
1. 计数排序
稳定性：稳定
时间复杂度：O(MAX(N,范围))
空间复杂度：O(范围)
原理：计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 统计相同元素出现次数，根据统计的结果将序列赋值到原来的序列中。
public static void countArray(int[] array){
int max=array[0]; //找到数组当中的最大值和最小值
int min=array[0];
for(int i=1;i< array.length;i++){
if(array[i]<min){
min=array[i];
}
if(array[i]>max){
max=array[i];
}
}
int range=max-min+1; //确定计数数组的大小
int[] count=new int[range];
//遍历原来的数组 把原来的数据 和 计数数组的下标进行对应，来计数
for(int i=0;i< array.length;i++){
int val=array[i];
count[val-min]++;
}
//遍历计数数组
int index=0;
for(int i=0;i<count.length;i++){
int val=count[i];
while(val!=0){
array[index]=i+min;
val--;
index++;
}
}
}2. 桶排序
稳定性：稳定
时间复杂度：O(N)
空间复杂度： O（n+k)
原理：桶排序是计数排序的扩展版本，桶排序是根据元素规模，每个桶存储一定范围的元素，根据桶的顺序将桶中的元素赋值到原始数组中。
public static void bucketSort(int[] array){
int max=array[0]; //找到数组当中的最大值和最小值
int min=array[0];
for(int i=1;i< array.length;i++){
if(array[i]<min){
min=array[i];
}
if(array[i]>max){
max=array[i];
}
}
int range=(max-min)/ array.length+1; //确定桶的数量
ArrayList<ArrayList<Integer>> bucket=new ArrayList<>(range);
for(int i=0;i< array.length;i++){
bucket.add(new ArrayList<Integer>());
}
//将每个元素放入桶
for(int i=0;i< array.length;i++){
int num=(array[i]-min)/(array.length);
bucket.get(num).add(array[i]);
}
//对每个桶进行排序
for(int i=0;i<bucket.size();i++){
Collections.sort(bucket.get(i));
}
//将桶中的元素赋值到原数组中
int index=0;
for(int i=0;i<bucket.size();i++){
for(int j=0;j<bucket.get(i).size();j++){
array[index++]=bucket.get(i).get(j);
}
}
}
123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
