归并排序 vs 快速排序含Java算法实现

最新推荐文章于 2024-05-14 09:00:00 发布

Oaktear

最新推荐文章于 2024-05-14 09:00:00 发布

阅读量877

点赞数 16

文章标签：算法 java 排序算法

本文链接：https://blog.csdn.net/weixin_45489847/article/details/135111801

版权

本文详细介绍了归并排序和快速排序的算法思想、实现过程、时间复杂度（归并排序为O(nlogn)，快速排序最差为O(n^2)），以及它们的相同点（分治思想）和不同点（归并自下而上、稳定，快速自上而下、不稳定，归并非原地O(n)，快速原地O(1)）。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

归并排序

算法思想：

先把数组从中间分成两部分，每个部分再继续划分直至最小粒度。
从最小粒度开始自下而上对数据进行排序。

算法实现：

需要用到一个临时数组tmp

public class Main {
 
    public static void main(String[] args) {
        int[] arr = {11,44,23,67,88,65,34,48,9,12};
        int[] tmp = new int[arr.length];    //新建一个临时数组存放
        mergeSort(arr,0,arr.length-1,tmp);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    
    public static void merge(int[] arr,int low,int mid,int high,int[] tmp){
        int i = 0;
        int j = low,k = mid+1;  //左边序列和右边序列起始索引
        while(j <= mid && k <= high){
            if(arr[j] < arr[k]){
                tmp[i++] = arr[j++];
            }else{
                tmp[i++] = arr[k++];
            }
        }
        //若左边序列还有剩余，则将其全部拷贝进tmp[]中
        while(j <= mid){    
            tmp[i++] = arr[j++];
        }
        
        while(k <= high){
            tmp[i++] = arr[k++];
        }
        
        for(int t=0;t<i;t++){
            arr[low+t] = tmp[t];
        }
    }
 
    public static void mergeSort(int[] arr,int low,int high,int[] tmp){
        if(low<high){
            int mid = (low+high)/2;
            mergeSort(arr,low,mid,tmp); //对左边序列进行归并排序
            mergeSort(arr,mid+1,high,tmp);  //对右边序列进行归并排序
            merge(arr,low,mid,high,tmp);    //合并两个有序序列
        }
    }
    
}

算法分析：

时间复杂度：

对 n 个元素进行归并排序所需要的时间是T(n)，那分解成两个子数组排序的时间都是 T(\frac{n}{2})，而合并两个子数组的时间复杂度为O(n)。
计算公式：C表示常量级的运行时间

$$
T(1) = C T(n) = 2 * T(\frac{n}{2}) + n = 2*[2*T(\frac{n}{4}) + \frac{n}{2}] + n = 4 * T(\frac{n}{4}) + 2n = ...
$$
可以求得T(n) = n*C + n\log_{2}(n)
因此时间复杂度为O(nlogn)
时间复杂度很稳定

空间复杂度：

不是原地排序算法，需要借助于临时数组
O(n)

快速排序

算法思想：

选择一个参考节点pivot
将小于pivot的元素放在pivot左边；大于pivot的元素放在pivot右边
对pivot左右两区间元素分别重复上述步骤，直到区间缩小为1
快排是自上而下的

算法实现：

public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];
 
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最后将基准为与i和j相等位置的数字交换
         arr[low] = arr[i];
         arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
 
 
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}