使用Java递归查找数组的最小值和最大值

Question

所以我正在尝试编写一个递归算法来找到数组的最小值和最大值。它基本上将数组分成两个 n/2 部分，并递归地找到最小值和最大值。这是我现在拥有的：

class MinMax{
    public static Pair mmA(int lb, int ub, int[] a){
        int min;
        int max;
        int mid;
        if (ub == lb){
            return mmA(lb, ub, a);
        } else {
            mid = (lb + ub)/2;
            mmA (lb, mid, a);
            max = mid;
            mmA (mid+1, ub, a);
            min = mid;

            if (a[max] > a[min]){
                return mmA(lb, max, a);
            } else 
                return mmA(min, ub, a);
        }
    }

    public static void main(String[]args){
        int[] a = {4, 3, 5, 6, 7, 9, 1};
        mmA(0, 6, a);
    }
}

问题是该方法不是 int 方法，所以我不能只说 max = mmA(lb, mid, a) 因为 mmA 是 Pair 方法，而 max 是 int。我也不能只制作 Max 和 Min 配对对象，因为那样你最终将无法比较它们。这是pair类：

class Pair {
   int alpha;   // the smaller one 
   int omega; // the bigger one 
   Pair ( int a, int o ) { alpha = a; omega = o; }
}

那么我怎样才能使用这个对类以及我的方法来找到最小值和最大值。

Answer 1

你不能。因为，这个函数最终会进入一个没有尽头的循环。

if (ub == lb){
    return mmA(lb, ub, a);
}

假设ub = lb = 5。它将再次调用mmA(5, 5, a)。这反过来又会调用相同的。等等……

编辑：

这应该会有所帮助，

public class Main {
    public static Pair mmA(int lb, int ub, int[] a) {
        int min, max, mid;
        Pair p1, p2;

        if (ub == lb) {
            return new Pair(a[lb], a[ub]);
        } else {
            mid = (lb + ub) / 2;
            p1 = mmA(lb, mid, a);
            p2 = mmA(mid + 1, ub, a);

            max = Math.max(p1.omega, p2.omega);
            min = Math.min(p1.alpha, p2.alpha);

            return new Pair(min, max);
        }
    }


    public static void main(String[] args) {
        int[] a = {4, 3, 5, 6, 7, 9, 1};
        Pair pair = mmA(0, 6, a);
        System.out.println("Max = " + pair.omega + " & Min = " + pair.alpha);
    }
}


class Pair {
    public int alpha;
    public int omega;

    Pair(int a, int o) {
        alpha = a;
        omega = o;
    }
}

Answer 2

由于这似乎是一个递归练习，让我试着以此为借口指导你。

您的递归方法返回一对，即最小值和最大值。通过将数组一分为二，您可以调用它两次。到目前为止一切顺利。

现在您有两对（假设您更改代码以实际将返回值分配给一个变量），您只需组合它们。假设您的 Pair 类是不可变的，那么您可以像这样向 Pair 添加一个方法：

public Pair combine(Pair other) {
    int newAlpha = Math.min(this.alpha, other.alpha);
    int newOmega = Math.max(this.omega, other.omega);
    return new Pair(newAlpha, newOmega);
}

注意：请注意，您的递归停止逻辑不起作用，如 answer by Msp 中所述。

Answer 3

您需要 Pair 类的 getter（或公开 alpha 和 omega 属性）：

class Pair {
   int alpha;   // the smaller one 
   int omega; // the bigger one 
   Pair ( int a, int o ) { alpha = a; omega = o; }
   getAlpha () { return alpha; }
   getOmega () { return omega; }
}

并且您必须停止在基本情况下返回 Pair 的递归 (lb = ub)

class MinMax{
    public static Pair mmA(int lb, int ub, int[] a){
        int min;
        int max;
        int mid;
        Pair pair1;
        Pair pair2;

        if (ub == lb){
            // Just one item, so min and max are the same
            return Pair(a[lb],a[ub]);
        } else {
            mid = (lb + ub)/2;
            pair1 = mmA (lb, mid, a);                
            pair2 = mmA (mid+1, ub, a);

            min = Math.min(pair1.getOmega(), pair2.getOmega());
            max = Math.max(pair1.getAlpha(), pair2.getAlpha());

            return new Pair(min, max);
        }
    }

    public static void main(String[]args){
        int[] a = {4, 3, 5, 6, 7, 9, 1};
        mmA(0, 6, a);
    }
}

Answer 4

问题似乎是你从来没有真正返回任何东西，正如@Andreas 所说，你没有组合你返回的结果。

这里我必须添加一个额外的条件，当上索引和下索引相邻时（即上 - 下 = 1），否则会发生无限循环。另外，我将您的变量名称更改为更具描述性。我发现自己在阅读它时迷失了方向。

public class MinMax {

    public static void main(String[] args){
        int[] array = {4, 3, 5, 6, 7, 9, 1};
        Pair result = mmA(0, array.length - 1, array);
        System.out.println("min: " + result.alpha + ", max: " + result.omega);
    }

    public static Pair mmA(int lowerBound, int upperBound, int[] array){
        if (upperBound == lowerBound){
            return new Pair(array[lowerBound], array[upperBound]);
        }
        else if (upperBound - lowerBound == 1) {
            int localAlpha = Math.min(array[lowerBound], array[upperBound]);
            int localOmega= Math.max(array[lowerBound], array[upperBound]);
            return new Pair(localAlpha, localOmega);
        }
        else {
            int midIndex = (lowerBound + upperBound)/2;
            Pair pairA = mmA(lowerBound, midIndex, array);
            Pair pairB = mmA(midIndex, upperBound, array);
            int localAlpha = Math.min(pairA.alpha, pairB.alpha);
            int localOmega= Math.max(pairA.omega, pairB.omega);
            return new Pair(localAlpha, localOmega);
        }
    }

}

class Pair {
    int alpha;   // the smaller one
    int omega; // the bigger one
    Pair ( int alpha, int omega ) {
        this.alpha = alpha;
        this.omega = omega;
    }
}