再帰を使用して配列の最大値を見つける
解決を求められた質問の1つとして、forループを使用して配列の最大値を見つけたので、再帰を使用してそれを見つけようとしましたが、これが私が思いついたものです。
public static int findMax(int[] a, int head, int last) {
int max = 0;
if (head == last) {
return a[head];
} else if (a[head] < a[last]) {
return findMax(a, head + 1, last);
} else {
return a[head];
}
}
だからそれはうまく機能し、最大値を取得しますが、私の質問は：基本ケースがa [head]を返し、先頭の値が最終的に>値である場合に問題はありませんか？
カウンタを1つだけにするだけで、今回は比較する値のインデックスだけで、同じように簡単に行うことができます。
_public static int findMax(int[] a, int index) {
if (index > 0) {
return Math.max(a[index], findMax(a, index-1))
} else {
return a[0];
}
}
_これは何が起こっているかをよりよく示し、デフォルトの「再帰」レイアウトを使用します。共通の基本ステップがあります。最初の呼び出しはfindMax(a, a.length-1)を実行することです。
それは実際にはそれよりはるかに簡単です。基本的なケースは、配列の最後（以下の3値制御ブロックの「その他」の部分）に達した場合です。それ以外の場合は、現在の呼び出しと再帰呼び出しの最大値を返します。
public static int findMax(int[] a) {
return findMax(a, 0);
}
private static int findMax(int[] a, int i) {
return i < a.length
? Math.max(a[i], findMax(a, i + 1))
: Integer.MIN_VALUE;
}
各要素で、現在の要素の大きい方と、より大きいインデックスを持つすべての要素を返します。 Integer.MIN_VALUEは空の配列でのみ返されます。これは線形時間で実行されます。
これを解決するには、再帰呼び出しごとに配列を半分に分割します。
findMax(int[] data, int a, int b)
ここで、aとbは配列インデックスです。
停止条件は、b - a <= 1、それらは隣人であり、最大はmax（a、b）;です。
最初の呼び出し：
findMax(int[] data, int 0, data.length -1);
これにより、最大再帰深度がNからlog2（N）に減少します。
しかし、検索作業は依然としてO（N）のままです。
これは
int findMax(int[] data, int a, int b) {
if (b - a <= 1) {
return Math.max(data[a], data[b]);
} else {
int mid = (a+b) /2; // this can overflow for values near Integer.Max: can be solved by a + (b-a) / 2;
int leftMax = findMax(a, mid);
int rightMax = findMax(mid +1, b);
return Math.max(leftMax, rightMax);
}
}
class Test
{
int high;
int arr[];
int n;
Test()
{
n=5;
arr = new int[n];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
high = arr[0];
}
public static void main(String[] args)
{
Test t = new Test();
t.findHigh(0);
t.printHigh();
}
public void printHigh()
{
System.out.println("highest = "+high);
}
public void findHigh(int i)
{
if(i > n-1)
{
return;
}
if(arr[i] > high)
{
high = arr[i];
}
findHigh(i+1);
return;
}
}
私はこのスレッドに出くわしました、そしてそれは私を大いに助けました。添付されているのは、再帰と分割統治の両方のケースでの私の完全なコードです。 divide＆conquerの実行時間は、再帰よりもわずかに優れています。
//use divide and conquer.
public int findMaxDivideConquer(int[] arr){
return findMaxDivideConquerHelper(arr, 0, arr.length-1);
}
private int findMaxDivideConquerHelper(int[] arr, int start, int end){
//base case
if(end - start <= 1) return Math.max(arr[start], arr[end]);
//divide
int mid = start + ( end - start )/2;
int leftMax =findMaxDivideConquerHelper(arr, start, mid);
int rightMax =findMaxDivideConquerHelper(arr, mid+1, end);
//conquer
return Math.max( leftMax, rightMax );
}
// use recursion. return the max of the current and recursive call
public int findMaxRec(int[] arr){
return findMaxRec(arr, 0);
}
private int findMaxRec(int[] arr, int i){
if (i == arr.length) {
return Integer.MIN_VALUE;
}
return Math.max(arr[i], findMaxRec(arr, i+1));
}
私はその古いスレッドを知っていますが、これが役立つかもしれません！
public static int max(int[] a, int n) {
if(n < 0) {
return Integer.MIN_VALUE;
}
return Math.max(a[n-1], max(a, n - 2));
}
これはどうですか ？
public static int maxElement(int[] a, int index, int max) {
int largest = max;
while (index < a.length-1) {
//If current is the first element then override largest
if (index == 0) {
largest = a[0];
}
if (largest < a[index+1]) {
largest = a[index+1];
System.out.println("New Largest : " + largest); //Just to track the change in largest value
}
maxElement(a,index+1,largest);
}
return largest;
}
最適化されたソリューション
public class Test1 {
public static int findMax(int[] a, int head, int last) {
int max = 0, max1 = 0;
if (head == last) {
return a[head];
} else if (a[head] < a[last]) {
max = findMax(a, head + 1, last);
} else
max = findMax(a, head, last - 1);
if (max >= max1) {
max1 = max;
}
return max1;
}
public static void main(String[] args) {
int arr[] = {1001, 0, 2, 1002, 2500, 3, 1000, 7, 5, 100};
int i = findMax(arr, 0, 9);
System.out.println(i);
}
}
次のように再帰的に行うことができます。
再発関係はこんな感じ。
f(a,n) = a[n] if n == size
= f(a,n+1) if n != size
実装は以下の通りです。
private static int getMaxRecursive(int[] arr,int pos) {
if(pos == (arr.length-1)) {
return arr[pos];
} else {
return Math.max(arr[pos], getMaxRecursive(arr, pos+1));
}
}
そして呼び出しはこのようになります
int maxElement = getMaxRecursive(arr,0);
大丈夫じゃない！あなたのコードは配列内の最大要素を見つけられません、それはその隣の要素より高い値を持つ要素のみを返します、この問題を解決するために、範囲内の最大値要素は再帰の引数として渡すことができます方法。
private static int findMax(int[] a, int head, int last,int max) {
if(last == head) {
return max;
}
else if (a[head] > a[last]) {
max = a[head];
return findMax(a, head, last - 1, max);
} else {
max = a[last];
return findMax(a, head + 1, last, max);
}
}
提案をありがとう@Robert Columbia！
pdate：この次の関数は、インデックス0から再帰的に開始し、配列の長さになるまでこのインデックス値に追加し続けます。それ以上の場合は、停止して0を返します。これを行うには、配列内の2つのアイテムごとに最大値を取得する必要があるため、たとえば次のようにします。
A = [1 , 2 , 3 ];
A[0] ( 1 ) vs A[1] ( 2 ) = 2
A[1] ( 2 ) vs A[2] ( 3 ) = 3
Max(2,3) = 3 ( The answer )
public int GetMax(int [] A, int index) {
index += 1;
if (index >= A.Length) return 0;
return Math.Max(A[index], GetMax(A, index + 1));
}