使用分治算法在java中查找整数数组中的最小元素

Question

我尝试使用我对分治算法的理解来找到整数数组中的最小元素。 我得到了正确的结果。 但我不确定这是否是使用分而治之算法的传统方式。 如果有任何其他比我尝试过的更智能的分治算法实现方法，请告诉我。

public static int smallest(int[] array){
       int i = 0;
       int array1[] = new int[array.length/2];
       int array2[] = new int[array.length - (array.length/2)];
       for(int index = 0; index < array.length/2 ; index++){
               array1[index] = array[index];
        }
        for(int index = array.length/2; index < array.length; index++){
               array2[i] = array[index];
                i++;
        }
        if(array.length > 1){
            if(smallest(array1) < smallest(array2)){
                return smallest(array1);
            }else{
                 return smallest(array2);
              }
        }
        return array[0];
   }

Answer 1

您的代码是正确的，但您可以使用Arrays.copyOfRange 和Math.min 等现有函数编写更少的代码

public static int smallest(int[] array) {
    if (array.length == 1) {
        return array[0];
    } 
    int array1[] = Arrays.copyOfRange(array, 0, array.length / 2);
    int array2[] = Arrays.copyOfRange(array, array.length / 2, array.length);
    return Math.min(smallest(array1), smallest(array2));        
}

还有一点。在开头测试length == 1 是更具可读性的版本。在功能上是相同的。从性能的角度来看，它创建的数组更少，并尽快从smallest 函数中退出。

还可以在不需要创建新数组的情况下使用不同形式的递归。

private static int smallest(int[] array, int from, int to) {
    if (from == to) {
        return array[from];
    }
    int middle = from + (to - from) / 2;
    return Math.min(smallest(array, from, middle), smallest(array, middle + 1, to));
}

public static int smallest(int[] array){
    return smallest(array, 0, array.length - 1);
}

第二个版本效率更高，因为它不会创建新数组。

Answer 2

我发现在这个特殊的程序中使用分而治之没有任何用处。

无论如何你搜索从 1 到 N 的整个数组，但是分两步

1. 1 to N / 2

2. N / 2 + 1 to N

这相当于 1 到 N。

您还可以在循环之后编写一些额外的检查程序，而这些检查在您直接执行时实际上并不需要。

int min = a[0];
for(int i = 1; i < arr.length; i++)
if(min < a[i])
  a[i] = min;

这被认为是找出最小值的最有效方法。

什么时候使用分而治之

分治算法的工作原理是递归地将一个问题分解为两个或多个子问题，直到这些子问题变得简单到可以直接解决。

考虑合并排序算法。

在这里，我们逐步划分问题，直到我们得到更小的问题，然后我们将它们组合起来进行排序。在这种情况下，这被认为是最佳的。正常运行时间为 O(n * n)，而这运行时间为 O(n log n)。

但是在找到最小值时，原始的有 O(n)。所以这很好。

分而治之

书

Data Structures and Algorithm Analysis in Java, 2nd edtition, Mark Allen Weiss

说一个 D&C 算法应该有两个不相交的递归调用。即喜欢快速排序。上面的算法没有这个，即使可以递归实现。

Answer 3

您在此处使用代码所做的操作是正确的。但是有更有效的方法来解决这个代码，我相信你已经知道了。

虽然分治算法可以应用于这个问题，但它更适合复杂的数据问题或通过将数据分成更小的片段来理解困难的数据问题。一个典型的例子是'Tower of Hanoi'。

就您的代码而言，它是正确的。这是相同代码的另一个副本-

public class SmallestInteger {

public static void main(String[] args) {
    int small ;
    int array[] = {4,-2,8,3,56,34,67,84} ;
    small = smallest(array) ;
    System.out.println("The smallest integers is = " + small) ;
}

public static int smallest(int[] array) {
    int array1[] = new int[array.length/2];
    int array2[] = new int[array.length - (array.length/2)];

    for (int index = 0; index < array.length/2 ; index++) {
        array1[index] = array[index];
    }
    for (int index = array.length/2; index < array.length; index++) {
        array2[index - array.length/2] = array[index] ;
    }

    if (array.length > 1) {
        if(smallest(array1) < smallest(array2)) {
            return smallest(array1) ;
        }
        else {
            return smallest(array2) ;
        }
    }
    return array[0] ;

}

}

结果出来了-

The smallest integers is = -2