《计算机算法设计与分析》课后练习05

最新推荐文章于 2024-07-15 13:03:29 发布

龙箬

最新推荐文章于 2024-07-15 13:03:29 发布

阅读量777

点赞数

分类专栏：国科大《计算机算法设计与分析》文章标签：排序算法算法 java

本文链接：https://blog.csdn.net/weixin_43975035/article/details/129578954

版权

国科大《计算机算法设计与分析》专栏收录该内容

9 篇文章 19 订阅

订阅专栏

Author:龙箬
Computer Application Technology
Change the World with Data and Artificial Intelligence !
CSDN@weixin_43975035
帘外桃花开仍旧，帘内人比桃花瘦

$\sqrt{n}$ 段合并排序算法：

如果在归并排序算法的分割步骤中，将数组 $a [0 : n - 1]$ 划分为 $\lfloor \sqrt{n} \rfloor$
个子数组，每个子数组中有 $O(\sqrt{n})$ 个元素，然后递归的对分割后的子数组进行排序。最后将所得到的 $\lfloor \sqrt{n} \rfloor$ 个排好序的子数组归并成排好序的数组 $a [0 : n - 1]$ 。
设计一个实现上述策略的归并排序算法，并分析算法的计算复杂性。

Java程序代码如下：

package com.company;

public class MERGESORT {
    public static void main(String[] args) {
        int[] a = {8, 13, 52, 34, 57, 47, 96, 905, 28, 12, 44, 176}; 
        mergesort(a, 0, a.length - 1);
        for (int k : a) {
            System.out.print(k + ",");
        }
    }

    private static void merge(int[] a, int i, int n1, int j, int n2) {
        int tmpi = i;
        int k = i;
        int[] p = new int[a.length];//临时数组
        while (i <= n1 && j <= n2) {
            if (a[i] < a[j])
                p[k++] = a[i++];
            else
                p[k++] = a[j++];
        }
        while (i <= n1)
            p[k++] = a[i++];
        while (j <= n2)
            p[k++] = a[j++];
        for (int o = tmpi; o <= n2; o++)
            a[o] = p[o];
    }

    public static void mergesort(int[] a, int left, int right) {
        if (left == right)
            return;
        int sqrt = (int) Math.sqrt(right - left + 1);
        for (int i = left, j = left; i <= right; i = j + 1) {
            j = Math.min(i + sqrt - 1, right);
            mergesort(a, i, j);
            if (i != left)
                merge(a, left, i - 1, i, j);
        }
    }

伪代码如下：

procedure mergesort(a[],low, high)
	//a(low: high)是一个全程数组，low和high分别指示当前待排序区间的最小下标和最大下标，它含有high-low+1≥0个待排序的元素
	integer low, high, i, j
	sqrt <- (int)Math.sqrt(right-left+1) //计算根号n分界点
	for(i=left, j=left; i<=right; i=j+1){
		j = Math.min(i + sqrt - 1, right);//计算每一个子集合结束位置
	mergesort(a, i, j);//递归调用每一个子集合排序
	if (i != left)
	merge(a, left, i - 1, i, j); //与其前一个子集合合并
	}
end mergesort

procedure merge(a[], int i, int n1, int j, int n2)  //使用辅助数组归并两个已排序的集合
    int tmpi <- i;
    int k <- i;
    int[] p = new int[a.length];//临时数组
    while (i <= n1 && j <= n2) { //处理处理两个已排序的序列，当两个集合都没有取尽时,将较小的元素先存放到P中
        if (a[i] < a[j]) //如果前一个数组中的元素较小
            p[k++] <- a[i++];
        else  //如果后一个数组中的元素较小
            p[k++] <- a[j++];
    }
    while (i <= n1)  //剩余元素处理过程
        p[k++] <- a[i++];
    while (j <= n2) //剩余元素处理过程
        p[k++] <- a[j++];
    for o <-tmpi to do a[o] <- p[o] repeat //将已排序的集合复制到a数组
end merge

时间复杂度：

$T(n) =n^{1/2}·T(n^{1/2})+O(n)$

$T(n^{1/2}) =n^{1/4}·T(n^{1/4})+O(n^{1/2})$

$T(n^{1/4}) =n^{1/8}·T(n^{1/8})+O(n^{1/4})$
$\begin{aligned} T(n) &=n^{1/2}[n^{1/4}·T(n^{1/4})+O(n^{1/2})]+O(n)\\ &=n^{1/2+1/4}·T(n^{1/4})+n^{1/2}·O(n^{1/2})+O(n)\\ &=......\\ &=n^{1/2+1/4+1/8+...+1/2^{x}}·T(n^{1/2^{x}})+n^{1/2^{x-1}}·O(n^{1/2^{x-1}})+...+n^{1/2}·O(n^{1/2})+O(n)\\ &<=n·T(1)+n^{1/2^{x-1}}·O(n^{1/2^{x-1}})+...+n^{1/2}·O(n^{1/2})+O(n) \end{aligned}$