Question

我在接受采访时被告知要编写一个程序来实现对分而治之概念的合并排序。

我写了下面的程序，

var myGlobalArray = undefined;

myGlobalArray = [8,4,17,2,1,32];
example01(myGlobalArray);

myGlobalArray = [48,14,17,2,11,132];
example01(myGlobalArray);

myGlobalArray = [45,14,5,2,1,12];
example01(myGlobalArray);

myGlobalArray = [45,-14,-5,2,1,-12];
example01(myGlobalArray);

myGlobalArray = [38,27,43,3,9,82,10];
example01(myGlobalArray);


function example01(myArray){
   var mainArray = [];

   createSubArray(myArray,0);

   mainArray = mergeArrays(mainArray);
   console.log(mainArray[0]);

   // creates an array which contains n arrays for n numbers present in myarray
   // i.e. if array = [ 34, 1, 27, 3 ] that the below method will return
   // [ [34], [1], [27], [3] ]
   function createSubArray(subArray,index){
        var localArray = [];

        if(subArray[index] !== undefined){
            localArray.push(subArray[index]);
            mainArray.push(localArray);
            createSubArray(subArray,++index);// performs division recursively   
        }       
   }//createSubArray


   // merge the arrays present i.e. 
   // if gblArray = [ [2,5], [1,7] ] 
   // then the below method will return
   // an merged array [ [1, 2, 5, 7] ]
   function mergeArrays(gblArray){
        var mergedArrays = [],
            main_array = gblArray,
            arr = [], 
            counter = 0, 
            nextCounter = 0;

        do{

            while(counter < main_array.length){
                nextCounter = counter + 1;

                if(main_array[nextCounter] !== undefined){
                    arr = mergeAndSort(main_array[counter],main_array[nextCounter]);    
                    mergedArrays.push(arr);
                }else{
                    mergedArrays.push(main_array[counter]);
                }
                counter = nextCounter + 1;
            }

            main_array = mergedArrays;
            mergedArrays = [];  
            counter = 0;
            nextCounter = 0;

        }while(main_array.length > 1);

        return main_array;
   }//mergeArrays


   // merges two array and sorts i.e.
   // if array1 = [23,1] and array2 = [4,12] than
   // the below method returns [1,4,12,23]
   function mergeAndSort(array1,array2){
        var array2Counter = 0, 
            array1Counter = 0, 
            mergedArray = [];

        while(array2Counter < array2.length && array1Counter < array1.length){

            if(array2[array2Counter] < array1[array1Counter]){
                mergedArray.push(array2[array2Counter]);
                array2Counter++;
            }else{
                mergedArray.push(array1[array1Counter]);
                array1Counter++;
            }
        }

        while(array1Counter < array1.length){
            mergedArray.push(array1[array1Counter]);
            array1Counter++;
        }

        while(array2Counter < array2.length){
            mergedArray.push(array2[array2Counter]);
            array2Counter++;
        }

        return mergedArray;
   } //mergeAndSort



}//example01

如果我运行上面的代码，输出是

[ 1, 2, 4, 8, 17, 32 ]
[ 2, 11, 14, 17, 48, 132 ]
[ 1, 2, 5, 12, 14, 45 ]
[ -14, -12, -5, 1, 2, 45 ]
[ 3, 9, 10, 27, 38, 43, 82 ]

但是通过查看我上面实现的合并排序程序，访问者说如果不遵循分而治之的概念。

我试图让他相信这种方法＆＃34; mergeArrays＆＃34;和＆＃34; mergeAndSort＆＃34; 做分而治之。但他并没有同意。

我哪里错了？

Answer 1

Wikipedia上分而治之的定义是：

基于多分支递归的算法设计范例。分而治之算法通过递归地将问题分解为相同或相关类型的两个或更多个子问题来工作，直到这些子问题变得足够简单以直接求解。然后结合子问题的解决方案来解决原始问题。

您的解决方案确实存在分歧，并且确实将解决方案组合在一起以提供最终解决方案，但它不会递归执行划分，从而使子问题逐渐更小。

修改：您执行使用递归，但不是按此处的方式使用。你的递归是tail-recursion，砍掉最小的单位（它们不会逐渐变小），并通过一系列递归调用重复这种斩波，这可以很容易地在循环中执行。

您的解决方案是bottom-up approach，而分而治之通常被理解为top-down method。虽然两种方法都是合并排序的有效实现，但严格来说，只有其中一种方法使用划分和征服范例。

但从更广泛的解释来看，分而治之也可以自下而上，放宽上面引用的定义中的一些要求。所以这最终可能是一个意见问题。

我的合并排序实现是否有分而治之？

1 个答案: