Java实现七大排序

Koba-yashi

已于 2024-10-27 20:18:37 修改

阅读量603

点赞数 13

分类专栏：数据结构文章标签： java 开发语言数据结构算法

于 2024-07-23 15:27:37 首次发布

本文链接：https://blog.csdn.net/lllsure/article/details/140628063

版权

数据结构专栏收录该内容

13 篇文章 1 订阅

订阅专栏

一.插入排序

1.直接插入排序

直接插入排序的原理与线下玩扑克牌类似。我们拿到一张牌后要排序，方法就是一张一张对。直接插入排序也是这样的，我们得到一张“牌”，从后往前对比，如果“牌”比刚得到的“牌”大就继续往前找，如果“牌”比刚得到的要小就插在它的后面。

//直接插入排序
public static void insetSort(int[] array){
    for(int i=1;i<array.length;i++){
        //从前往后遍历
        int j=i-1;
        int tem=array[i];   //当前i的值
        for(;j>=0;j--){
            if(array[j]>tem){
                //如果比tem大就继续往前找
                array[j+1]=array[j];
            }else{
                //如果比tem小就插在j的后面，也就是j+1的位置
                array[j+1]=tem;
                break;
            }
        }
        //如果找到头都没找到，说明其实最小的
        array[j+1]=tem;
    }
}

特性：当数组越有序，时间效率越高。

2.希尔排序

又名缩小增量排序。希尔排序是直接插入排序的优化，其时间复杂度最坏就是直接插入排序。思路是先分小组，组内排序；再分组，但组内元素增多，组内排序，直到最后只分1组，这时再进行排序就有序了。

首先我们要解决这么分组的问题。

如图，正常我们想到的是第一种分组，将连续的几个元素分成一组。但希尔排序用的是第二种，定义一个gap，让前一个加上一个gap找到第二个。

前面说了希尔排序是直接插入排序的优化，其代码和直接插入排序极其相似。

//希尔排序
public static void shellSort(int[] array){
    int gap=array.length/2;
    //分组
    while(gap>1){
        gap=gap/2;
        shell(array,gap);
    }
}
//直接插入排序的变种
private static void shell(int[] array, int gap) {
    for(int i=gap;i<array.length;i++){
        int j=i-gap;
        int tem=array[i];
        for(;j>=0;j-=gap){
            if(array[j]>array[j+gap]){
                array[j+gap]=array[j];
            }else{
                array[j+gap]=tem;
                break;
            }
        }
        array[j+gap]=tem;
    }
}

二.选择排序

1.选择排序

选择排序的原理很简单，从前到后遍历每一个元素，再遍历这个元素后面的元素，找到后面比该元素更小的元素，交换其位置即可。

public static void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int mindIndex = i;
        for (int j = i+1; j < array.length; j++) {
            if(array[j] < array[mindIndex]) {
                mindIndex = j;
            }
        }
        swap(array,i,mindIndex);
    }
}

这种方式排序比较慢，我们可以对其进行优化，优化思路：同时排序大值和小值。

public static void SelectSortOptimize(int[] array){
    int left=0;
    int right=array.length-1;

    while(left<right){
        int minIndex=left;
        int maxIndex=left;

        for (int i = left+1; i <= right; i++) {
            if(array[i]>array[maxIndex]){
                maxIndex=i;
            }
            if(array[i]<array[minIndex]){
                minIndex=i;
            }
        }

        swap(array,left,minIndex);
        if(maxIndex==left){
            //因为left已经被minIndex换走了
            maxIndex=minIndex;
        }
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

2.堆排序

在堆排序中，要想升序排序要大根堆，要降序需要小根堆。思路：定义一个引用指向堆的最后一个元素，将堆顶元素与指向元素交换，然后指向向前移动，将堆顶元素进行向下调整。

public static void heapSort(int[] array){
    createHeap(array);
    for(int i=array.length-1;i>0;i--){
        swap(array,0,i);
        siftdown(array,0,i);
    }
}

三.交换排序

1.冒泡排序

这个太经典了，每个学编程都绕不开的。原理跟选择排序差不多，不过冒泡排序是直接交换。

   public static void bubbleSort(int[] array){
        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]){
                    swap(array,j,j+1);
                }
            }
        }
    }

这个已经是优化过的版本了，当然这个代码还可以再进行优化。优化思路：当 i 后面的元素全部有序后就不进行排序了直接退出循环。

public static void bubbleSortOptimize(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(!flg) {
                break;
            }
        }
    }

2.快速排序（重要）

快速排序是 Hoare 于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

简短的说，从序列挑一个元素作为基准，让比基准元素小的元素放在该元素的左面，比它大的元素放在右面。再把基准元素右面的看作一组，左面看作一组，在进行刚刚的操作，直到某一组只有一个元素的时候停止。

public static void quickSort(int[] arr,int left,int right){
        if(left>=right){
            return ;
        }

        int l=left;
        int r=right;

        int cur=arr[left];

        while(left<right){

            while(left<right && arr[right]>=cur){
                right--;
            }
            arr[left]=arr[right];
            while(left<right && arr[left]<=cur){
                left++;
            }
            arr[right]=arr[left];
        }
        arr[left]=cur;

        quickSort(arr,l,left-1);
        quickSort(arr,left+1,r);
    }

这个是以左端点为基准，右端点、中间点等都可以作为基准，序列任何没被当过基准点都可以当基准点。

这个是以中间点为基准的：

public static void quickSort(int[] array,int left,int right){
            if(left >= right){
                return ;
            }
            //x为基准
            int x = array[(left+right)/2];
            int i = left - 1;
            int j = right + 1;

            while(i < j){
                do{
                    i ++ ;
                }while (array[i] < x);
                
                do {
                    j--;
                }while (array[j] > x);
                
                if(i < j){
                    swap(array,i,j);
                }
            }

            quickSort(array, left, j);
            quickSort(array, j + 1, right);
    }

前后两个引用指向，前面的先走，找到第一个比基准大的数停下；后面的走，找到第一个比基准小的数停下，将两个指向的值交换。继续重复上面的步骤，直到两个指向相遇。相遇时保证了基准左面都比基准小，右面都比基准大。

四.归并排序

采用分治法，先将序列分解，再将已有序的子序列合并，最终得到全部元素有序。若将两个有序表合并成一个有序表，称为二路归并。

public static void mergeSort(int[] array,int left,int right){
        if(left>=right){
            //终止条件
            return ;
        }

        //分解
        int mid=(left+right)/2;
        mergeSort(array,left,mid);
        mergeSort(array,mid+1,right);

        //合并
        int[] tem=new int[right-left+1];
        int k=0;
        int s1=left,e1=mid;
        int s2=mid+1,e2=right;

        while(s1<=e1 && s2<=e2){
            if(array[s1]>array[s2]){
                tem[k++]=array[s2++];
            }else{
                tem[k++]=array[s1++];
            }
        }
        
        //把剩下没有遍历到的放入临时数组
        while(s1<=e1){
            tem[k++]=array[s1++];
        }
        while(s2<=e2){
            tem[k++]=array[s2++];
        }

        for (int i = 0; i < k; i++) {
            array[i+left]=tem[i];
        }
    }

五.总结

排序方法	最好	平均	最坏	空间复杂度	稳定性
直接插入排序	O( $n$ )	O( $n^{2}$ )	O( $n^{2}$ )	O(1)	稳定
希尔排序	O( $n$ )	O( $n^{1.3-1.5}$ )	O( $n^{2}$ )	O(1)	不稳定
选择排序	O( $n^{2}$ )	O( $n^{2}$ )	O( $n^{2}$ )	O(1)	不稳定
堆排序	O( $n*log(n)$ )	O( $n*log(n)$ )	O( $n*log(n)$ )	O(1)	不稳定

排序方法	最好	平均	最坏	空间复杂度	稳定性
冒泡排序	O( $n^{2}$ )	O( $n^{2}$ )	O( $n^{2}$ )	O(1)	稳定
快速排序	O( $n*log(n)$ )	O( $n*log(n)$ )	O( $n^{2}$ )	O( $log$ (n))~O( $n$ )	不稳定
归并排序	O( $n*log(n)$ )	O( $n*log(n)$ )	O( $n*log(n)$ )	O( $n$ )	稳定