Question

我发现时间复杂度存在问题。

事实上，谈到MergeSort中的外部FOR，我认为重复是（1+ Sumation（从i = 1，到sizeOfArray）（2 * i）= 1+（2 + 4 + 8 + 16 + 32） + ... +尺寸）但我也认为我错了。
我在测量内部FOR循环重复时也遇到了问题。

MergeSort （）{// Iterative Version（自下而上）

            for(int currentSize = 1; currentSize < length; currentSize *= 2)        {
                for(int low = 0; low < length - currentSize; low += 2*currentSize){

                    int mid = low + currentSize - 1;
                    //min() is used here so if low is very close to the end of the array, high doesn't take outOfBoundries Value.
                    int high = Math.min(low + currentSize*2 -1, length - 1);

                }
            }

}

合并（int low，int middle，int high）{

            // Copy both parts into the helper array
            for (int i = low; i <= high; i++) {
                    helper[i] = arrayForMergeSort[i];
            }

            int i = low;
            int j = middle + 1;
            int k = low;
            // Copy the smallest values from either the left or the right side back
            // to the original array
            while (i <= middle && j <= high) {
                    if (helper[i] <= helper[j]) {

                            arrayForMergeSort[k] = helper[i];
                            i++;
                    } else {

                            arrayForMergeSort[k] = helper[j];
                            j++;
                    }
                    k++;
            }
            // Copy the rest of the left side of the array into the target array
            while (i <= middle) {
                    arrayForMergeSort[k] = helper[i];
                    k++;
                    i++;
            }

    }

Answer 1

对于外循环，迭代次数为ceil（log2（length））。

对于内部循环，每次迭代要合并的运行次数为ceil（length / currentSize）或floor（（length + currentSize - 1）/ currentSize）。如果这是偶数，则最后一次运行的大小可能小于currentSize。如果这是一个奇数，那么最后一次运行没有要合并的运行，也可能小于currrentSize。我不确定是否有办法计算合并操作的总数而不使用迭代来对每次迭代的合并操作求和。

在＆＃34;生产＆＃34;合并排序的版本，工作数组的一次性分配与原始数组的大小相同（或1/2），然后合并的方向（原始到工作或工作原始的每个外部循环都会改变如果程序预先计算外部迭代的数量，并且它是一个奇数，则可以在初始传递中进行预传递以交换元素，从而完成偶数个合并传递，排序后的数据以原始数组结尾。

迭代MergeSort时间复杂度（自下而上）

1 个答案: