Schreiben Sie eine rekursive Funktion in Java, um den Maximalwert eines Arrays zu ermitteln

So verwenden Sie Java, um rekursiv den Maximalwert eines Arrays zu erreichen

public static void main(String[] rags){

int [] target = new int[100];

int point = 0;

//....Initialisieren Sie das Array hier

int max = target[0];

max = getMax(max,point,aim);

//...Sonstige Verarbeitung

}

//Rekursive Methode

public int getMax(int ​​​​max,int point,int[] target){

if(point==aim.length) //kritischer Wert

Rückgabe max;

//Wenn der kritische Wert nicht erreicht wird, nehmen Sie den Maximalwert und führen Sie eine Rekursion durch

max = max >= Ziel[Punkt] ? max : Ziel[Punkt];

return getMax(max,point+1,aim);

}

So implementieren Sie den rekursiven Algorithmus der binären Suche in Java

Binäre rekursive Suche in öffentlichen Klassen {

public static void main(String[] args) {

//Definieren Sie das Array. Beachten Sie, dass das binäre Sucharray ein geordnetes Array sein muss!

int[] arr = { 1, 3, 5, 7, 9, 11, 13, 15, 17 };

//Akzeptiere den Rückgabewert nach der Suche: Indexwert, wenn nicht, ist er -1;

//Testelement finden: 9

int a=binary(arr, 9, 0, arr.length - 1);

System.out.println ("Die Indexposition der gesuchten Nummer ist: "+a);

}

//Die Parameterliste ist: zu durchsuchendes Array, zu suchende Nummer, Kopfindex, Endindex!

öffentliche statische int-Binärdatei (int[] arr, int key, int star, int end)//Rekursion

{

//Jedes Mal, wenn es eingeht, wird es mit dem Zwischenindexwert erstellt!

int mid = (Stern + Ende) / 2;

//Wenn die gesuchte Zahl kleiner als der Kopf- oder Schwanzindex ist oder der Kopfindex größer als der Schwanzindex ist, bedeutet dies, dass es keine solche Zahl gibt und -1 zurückgegeben wird;

if (key arr[end] || star > end) {

return -1;

}

//Wenn der Mittelwert kleiner als die gesuchte Zahl ist, definieren Sie den Header-Index neu und verschieben Sie ihn an die mittlere +1-Position, wodurch die Hälfte der Zahlen herausgefiltert wird!

if (arr[mid]

//Rekursion starten!

binär zurückgeben(arr, key, mid + 1, end);

//Andernfalls, wenn der mittlere Wert größer als die gesuchte Zahl ist, verschieben Sie den Endindex auf die mittlere -1-Position und filtern Sie die Hälfte der Zahlen heraus!

} else if (arr[mid] > key) {

//Rekursion starten!

binär zurückgeben(arr,key, star, mid - 1);

} sonst {

//Wenn nicht, wird es gefunden, zurück zum Index!

Rückkehr Mitte;

}

}

}

Wie die Rekursion von Java ausgeführt wird und wie der Befehl ausgeführt wird

factest(8) ruft die Funktion factest auf, if(n==1) return 1; // Wenn nicht etabliert, sonst return n*factest(n-1); // Der Rückgabewert ist 8*factest(7 )

factest(7) gibt die Factest-Funktion ein, if(n==1) return 1; // Wenn nicht etabliert, sonst ausführen

else return n*factest(n-1); // Der Rückgabewert ist 7*factest(6)

……

Bis N=1, zu diesem Zeitpunkt if(n==1) return 1; // Festgelegt, ist der Rückgabewert 1, also 1!=1

Dann berechnen Sie den Rückgabewert von factest(2) als: 2*factest(1) = 2

Berechnen Sie dann weiter den Rückgabewert von factest(3): 3*factest(2) = 6

... Bis N=8 erhalten wir factest(8) = 8*factest(7) = 40320

Wie verwende ich Rekursion, um dieses Problem in JAVA Master zu lösen? Das rekursive Java-Programm, das Sie schreiben möchten, lautet wie folgt:

java.util.Scanner importieren;

öffentliche Klasse GGG {

public static void main(String[] args) {

int N = 0;

Scanner sc=new Scanner(System.in);

int num=sc.nextInt();

for(int n=0;n

N=sc.nextInt();

int a[]=new int[N];

for(int i=0;i

a[i]=sc.nextInt();

}

System.out.print("case"+(n+1)+":");

Prozess(a,0);

System.out.println();

}

}

privater statischer Void-Prozess (int[] a, int n) {

if(n==0){

if(isPrime(a[n+1]))

System.out.print(1+＂＂);

sonst

System.out.print(0+＂＂);

}else if(n==a.length-1){

if(isPrime(a[n-1]))

System.out.print(1+＂＂);

sonst

System.out.print(0+＂＂);

zurück;

}sonst{

if(isPrime(a[n-1])&isPrime(a[n+1]))

System.out.print(2+＂＂);

else if(isPrime(a[n-1])||isPrime(a[n+1]))

System.out.print(1+＂ ＂);

sonst

System.out.print(0+＂＂);

}

Prozess(a,n+1);

}

public static boolean isPrime(int num) {

int i;

for(i=2;i

if(num%i==0)

Pause;

}

if(i==num){

true zurückgeben;

}

false zurückgeben;

}

}Laufergebnis:

2

5

5 7 2 9 13

Fall 1:1 2 1 2 0

3

10 4 5

Fall 2:0 1 0

Das obige ist der detaillierte Inhalt vonSchreiben Sie eine rekursive Funktion in Java, um den Maximalwert eines Arrays zu ermitteln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!