Question

我正在学习计算机科学，我们目前的任务是编制合并排序算法，其数组长度为2 ^ k（k = 1-16），随机数和每个位置。我们必须通过总计所有递归数组调用的长度来输出该算法的运行时。

我们的老师给出了以下示例：数组长度= 4： runtime = 2 * 2 + 4 * 1 = 8

我当前的逻辑是每个实例都只是数组的长度，这就是为什么我认为它足以在每次递归调用后添加array.length。但这会打电话太多......

我的阵列输出......

长度4：4 8 12（0 ... 3）

长度8：8 16 24 32 40 48 56（0 ... 7）

长度16:16 32 48 64 80 96 112 128 144 160 176 192 208 224 240（0 ... 15）

有一点很清楚，输出总是等于初始数组长度。我已将正确的值设为粗体，这些值应该是最终输出...如果我理解正确的话。

有人可以帮助我进行运行时计算吗？

我的代码：

请记住，intArr-size通常不是16 [或8或4]，而是＆＃34; value＆＃34;这是2 ^ k参考。我已经降低了大小，以便更容易找到运行时计算中的失败。

import java.util.Random;

public class Mergesort {

    Random generator = new Random();

    static int runtime;
    static int base = 2;
    static int potency = 1 + (int) (Math.random() * ((16)));
    static int value = (int) java.lang.Math.pow(base, potency);
    public static int[] intArr = new int[16];

    {
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = generator.nextInt(100);
        }
    }

    public static void main(String[] args) {
        Mergesort ms = new Mergesort();
        int[] arr = ms.splitHalf(0, intArr.length - 1); 

        System.out.println("Mergesort-Algorithm" + "\n" + "\n" + "Position:" + " Wert");
        for (int i = 0; i < arr.length; i++) { 
            System.out.println(i + 1 + ": " + arr[i]);
        }
    }

    public int[] splitHalf(int l, int r) { 
        if (l < r) { 
            int q = (l + r) / 2;
            splitHalf(l, q); 
            splitHalf(q + 1, r); 
            merge(l, q, r); 
        }
        return intArr; 
    }

    private void merge(int l, int q, int r) { 
        int[] arr = new int[intArr.length];
        int left;
        int right;

        for (left = l; left <= q; left++) {
            arr[left] = intArr[left];
        }
        for (right = q + 1; right <= r; right++) {
            arr[r + q + 1 - right] = intArr[right];
        }
        left = l;
        right = r;
        for (int k = l; k <= r; k++) { 
            if (arr[left] <= arr[right]) { 
                intArr[k] = arr[left]; 
                left++; 
            } else {
                intArr[k] = arr[right]; 
                right--; 
            }
        }
        runtime = runtime + arr.length;
        System.out.println(runtime);
    }
}

Answer 1

您正在使用整数数组intArr，它在整个程序中具有固定长度。因此，每次执行runtime = runtime + arr.length;时，都会添加数组的初始长度。但是，它需要添加当前的＆＃34;范围＆＃34;你正在努力获得正确的数字。

您应该更改方法界面以获得更好的代码结构。

// gets two sorted arrays and returns the merged sorted array of both
static int[] merge(int[] firstSortedArray, int[] secondSortedArray) {
    int[] result = int[firstSortedArray.length + secondSortedArray.length];
    // merge both arrays into result
    return result;
}

// gets an input array and returns the same array in a sorted fashion
static int[] split(int[] inputArray) {
    // an array of size zero/one is already sorted and can be return unchanged
    if(inputArray.length == 0 || inputArray.length == 1)
        return inputArray; 

    int[] leftSortedHalf = split(/*copy first half here*/);
    int[] rightSortedHalf = split(/*copy second half here*/);
    return merge(leftSortedHalf, rightSortedHalf);
}

MergeSort - 如何总结所有递归数组调用？

1 个答案: