Bagaimana untuk mengendalikan sejumlah besar data dengan panggilan rekursif dalam fungsi Java?

Kaedah untuk memproses sejumlah besar data secara rekursif termasuk: menggunakan gelung dan bukannya rekursi untuk mengelakkan limpahan tindanan. Gunakan kaedah divide-and-conquer untuk memecahkan masalah besar kepada sub-masalah yang lebih kecil. Gunakan pengoptimuman mesin maya Java untuk rekursi ekor untuk mengelakkan limpahan tindanan.

Cara Panggilan Rekursif dalam Fungsi Java Memproses Data Besar di tengah. Untuk mengelakkan ini, kaedah berbeza boleh digunakan untuk mengendalikan sejumlah besar data sambil mengekalkan kelebihan panggilan rekursif.

Gunakan gelung dan bukannya rekursif

Salah satu cara ialah menukar fungsi rekursif kepada fungsi berulang, menggunakan gelung dan bukannya panggilan rekursif untuk memproses data. Ini boleh mengurangkan dengan ketara memori yang diperlukan untuk susunan panggilan fungsi, dengan itu meningkatkan prestasi aplikasi.

public static int factorial(int n) {
  int result = 1;
  for (int i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

Gunakan kaedah divide and conquer

Pendekatan lain ialah menggunakan kaedah divide and conquer, yang memecahkan masalah besar kepada sub-masalah yang lebih kecil. Dengan berulang kali memecahkan masalah kepada bahagian yang lebih kecil, anda boleh mengurangkan jumlah data yang diproses dengan setiap panggilan rekursif.

public static int mergeSort(int[] arr, int start, int end){ 
  if (start < end) {
    int mid = start + (end - start) / 2; 
    mergeSort(arr, start, mid); 
    mergeSort(arr, mid + 1, end); 
    merge(arr, start, mid, end); 
  } 
  return arr; 
}

public static void merge(int[] arr, int start, int mid, int end) { 
  int[] temp = new int[end - start + 1];  
  int left = start; 
  int right = mid + 1; 
  int k = 0; 

  while (left <= mid && right <= end) { 
    if (arr[left] < arr[right]) { 
      temp[k] = arr[left]; 
      left++; 
    } 
    else { 
      temp[k] = arr[right]; 
      right++; 
    } 
    k++; 
  } 
} 

Pengoptimuman Rekursif Ekor

Mesin Maya Java (JVM) dioptimumkan untuk panggilan rekursif ekor. Oleh itu, jika fungsi rekursif adalah rekursif ekor, JVM boleh mengoptimumkannya untuk mengelakkan limpahan tindanan.

public static int factorial(int n) {
  return factorialHelper(n, 1);
}

private static int factorialHelper(int n, int acc) {
  if (n == 0) {
    return acc;
  }
  return factorialHelper(n - 1, acc * n);
}

Contoh Praktikal

Pertimbangkan fungsi yang mengira nombor ke-n dalam jujukan Fibonacci. Fungsi ini ditakrifkan seperti berikut menggunakan rekursi:

public static int fibonacci(int n) {
  if (n == 0) {
    return 0;
  }
  if (n == 1) {
    return 1;
  }
  return fibonacci(n - 1) + fibonacci(n - 2);
}

Menggunakan

gelung dan bukannya rekursi, fungsi Fibonacci boleh ditukar kepada fungsi lelaran berikut:

public static int fibonacci(int n) {
  if (n == 0) {
    return 0;
  }
  if (n == 1) {
    return 1;
  }
  int prev = 0;
  int curr = 1;
  for (int i = 2; i <= n; i++) {
    int next = prev + curr;
    prev = curr;
    curr = next;
  }
  return curr;
}

Kaedah lelaran ini boleh mengira Fibonacci Nombor Besar dalam urutan limpahan tindanan dengan berkesan kesilapan.

Atas ialah kandungan terperinci Bagaimana untuk mengendalikan sejumlah besar data dengan panggilan rekursif dalam fungsi Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!