分治法-2 sort

最新推荐文章于 2022-11-19 22:50:58 发布

E5dison

最新推荐文章于 2022-11-19 22:50:58 发布

阅读量113

点赞数

分类专栏：算法设计文章标签：算法

本文链接：https://blog.csdn.net/weixin_44668146/article/details/107245966

版权

算法设计专栏收录该内容

11 篇文章 1 订阅

订阅专栏

归并排序和快速排序

1 简介

一般来说，使用分治思想的排序算法有归并排序和快速排序，在理想情况下，它们的时间复杂度都为 $O(nlog_n)$ ，递归式均为:
$T (n) = 2 T (n / 2) + O (n)$
基本思路均如下图，只是各自的分解、排序和合并的方式有所不同：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hjmWs1iJ-1594349682224)(D:\CS-Recorder\CS-2-2\ADA\Divider-and-Conquer\sort-1.PNG)]

归并排序分解容易，合并麻烦。而快速排序分解麻烦，合并容易。两者各有优劣。下面为具体介绍。

2 归并排序

伪代码如下：

Merge(L,nl,R,nr):
	n=nl+nr
	create array A
	i=0,j=0
	for k=1 to n:
		if i<nl and (j>nr or L[i]<=R[j]):
			A[k]=L[i]
			i=i+1
		else:
			A[k]=R[j]
			j=j+1
	return A

Merge-Sort(A,n):
	if n>1:
		p=n/2
		B=A[0..p]
		C=A[p+1..n]
		Merge-Sort(B,p)
		Merge-Sort(C,n-p)
		A=Merge(B,p,C,n-p)

实例代码（java）如下：

    public static void mergeSort(long[] A, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(A, low, mid);
            mergeSort(A, mid + 1, high);
            merge(A, low, mid, high);
        }
    }

    public static void merge(long[] A, int low, int mid, int high) {
        long[] B = new long[high - low + 1];
        int i = low, j = mid + 1;
        for (int k = 0; k < high - low + 1; k++) {
            if (i <= mid && (j > high || A[i] < A[j])) {
                B[k] = A[i];
                i++;
            } else {
                B[k] = A[j];
                j++;
            }
        }
        int t = 0;
        for (int k = low; k <= high; k++) {
            A[k] = B[t];
            t++;
        }
    }

3 快速排序

快速排序是一个随机化的算法，它的复杂度在理想情况下是O(nlogn)，但是如果分界点选取不当，也可能退化成冒泡排序。因此我们采用随机选取分界点的方式来优化该算法。

Partion(A,p,r):
	x=A[r]
	i=p-1
	for j=p to r-1:
		if A[j]<=x:
			i=i+1
			exchange(A[i],A[j])
	exchange(A[i+1],A[r])
	return i+1

Random-Partion(A,p,r):
	i=Random(p,r)
	exchange(A[i],A[r])
	return Partion(A,p,r)

Quick-sort(A,p,r):
	if p<r:
		q=Random-Partion(A,p,r)
		Quick-sort(A,p,q-1)
		Quick-sort(A,q+1,r)