用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對對象，因為這樣一來，您將無法在最后進行比較。 這是配對類：

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);
}

注意：請注意，您的遞歸停止邏輯不起作用，如Msp的回答所述。

Answer 3

您需要使用Pair類的吸氣劑（或公開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; }
}

而且您必須停止在基本情況下返回對（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;
    }
}