汇总几种常见的排序方法(java)

前言

不同的排序方法对应着不同的时间复杂度，也对应着不同的应用场景，比如数据量较小的时候，我们可以直接采用冒泡排序和插入排序，但是数据量一大起来，冒泡排序O(n^2)的时间复杂度有显得有一些臃肿了。本文列出了几种常见的排序方法，并附上一些可能的应用场景。

几种常见的排序

下面是几种常见排序的时间复杂度

冒泡排序和插入排序

不多数，直接附上代码，属于最基础的排序

冒泡排序

//冒泡排序法的快速调用
    public static int[] bubbleSort(int []arr){
     
        for (int i = arr.length-1;i >= 0 ; i--) {
     
            for(int j =0;j < i ;j++){
     
                if(arr[j] > arr[j+1]){
     
                    int temp =arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }

插入排序的两种写法

//写法1
public static void insertSort(int []arr){
     
        int temp;
        for (int i=1;i< arr.length; i++) {
     
            for(int j=i;j>0;j--){
     
                //arr[i]分别与它左边的每一个数字进行比较，如果碰到比它大的，则交换数据
                //直到碰到比它小的数字
                if(arr[j]<arr[j-1]){
     
                    temp = arr[j];
                    arr[j] =arr[j-1];
                    arr[j-1] = temp;
                }else{
     
                    break;
                }
            }
        }
    }

//写法2
public static int[] insertSort(int []arr){
     
        if(arr==null) return null;
        //从第二个开始排序
        int temp;
        for(int i=1;i< arr.length;i++){
     
            //将第i个数字一次和前面的每一个比较
            //如果a
            //如果a>=j,break
            int j =0;
            temp =arr[i];
            for(j=i-1;j>=0;j--){
     
                if(arr[j]>temp){
     
                    arr[j+1] =arr[j];
                }else{
     
                    break;
                }
            }
            arr[j+1]=temp;
        }
        return arr;
    }

快速排序

是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

代码部分：

	//运用方法重载,可以忽略begin和end
    public static void quickSort(int []arr) {
     
        quickSort(arr,0, arr.length-1);
    }
    public static void quickSort(int []arr,int begin,int end){
     
        //设置停止位
        //递归到最小的时候begin==end,不设置停止位的话递归不会停止，直到数组下标移动到负数截止
        if(begin > end) return;
        //设定一个标志值
        int temp=arr[begin],mid;
        int i=begin,j=end;
        //当左右指针不相等的时候,一直进行内部的比较
        while(i!=j){
     
            //要先判断右指针再判断左指针
            //当右指针值大于标志数，左移，直到碰到小于标志数的值，退出循环
            while(arr[j]>=temp&&j>i){
     
                j--;
            }
            //当左指针值小于标志数，右移，直到碰到大于标志数的值，退出循环
            while(arr[i]<=temp&&j>i){
     
                i++;
            }
            //两指针停止后，交换数值
            if(j>i){
     
                mid =arr[i];
                arr[i] =arr[j];
                arr[j] =mid;
            }
        }
        //运行到这里说明左右指针位置相等
        //这个时候该位置的值与标志值交换
        arr[begin] = arr[i];
        arr[i] =temp;
        //以标志位为分界，左右分为两个区域，继续执行该操作
        quickSort(arr,begin,i-1);
        quickSort(arr,i+1,end);
    }

参考文献：八大排序算法

持续更新…