Memahami dan Melaksanakan Algoritma Pendaraban Karatsuba untuk Nombor Besar

Dalam matematik pengiraan, pendaraban nombor besar dengan cekap adalah asas kepada pelbagai aplikasi, daripada kriptografi kepada pengkomputeran saintifik. Algoritma pendaraban Karatsuba ialah kaedah bahagi-dan-takluk yang meningkatkan prestasi dengan ketara berbanding pendaraban panjang tradisional untuk nombor besar. Dalam artikel ini, kami akan meneroka pelaksanaan JavaScript bagi algoritma berkuasa ini yang direka untuk mengendalikan nombor besar secara sewenang-wenangnya yang diwakili sebagai rentetan.

---

Masalah Pendaraban Tradisional

Kaedah pendaraban "buku sekolah" standard mempunyai kerumitan masa $(O(n^2))$(O(n2)) , di mana $(n)$(n) ialah bilangan digit dalam nombor yang didarab. Pertumbuhan kuadratik ini menjadi mahal secara pengiraan apabila bilangannya semakin besar. Algoritma Karatsuba, yang diperkenalkan oleh Anatolii Karatsuba pada tahun 1960, mengurangkan kerumitan ini kepada lebih kurang $(O(n^{1.585}))$(O(n1.585)) , menjadikannya pilihan yang lebih pantas untuk input yang besar.

---

Cara Algoritma Karatsuba Berfungsi

Algoritma bergantung pada strategi bahagi-dan-takluk:

1. Bahagi: Bahagikan setiap nombor kepada dua bahagian—bahagian tinggi dan bahagian rendah.
2. Menakluk: Kira tiga produk utama secara rekursif: Ini melibatkan pengiraan komponen berikut untuk setiap langkah rekursif:
   • $z_0=\text{rendah1}\times \text{rendah2}$z0​ =rendah1×rendah2
   • $z_1=(\text{rendah1}\text{tinggi1})\times (\text{rendah2}\text{tinggi2})$z1​=(rendah1 tinggi1)×(rendah2 tinggi2)
   • ${}_{\mathrm{}}=tinggi1\times tinggi2z\_2\; =\; teks\{tinggi1\}\; kali\; teks\{tinggi2\}$z2​=tinggi1×tinggi2
3. Gabungkan: Gunakan formula:
   $$hasil={}_{\mathrm{}}\cdot 1\mathrm{}{\mathrm{}}^{2\mathrm{}\cdot m}({}_{\mathrm{}}-{}_{\mathrm{}}-{}_{\mathrm{}})\cdot 1\mathrm{}{\mathrm{}}^{}{}_{\mathrm{}}teks\{hasil\}\; =\; z\_2\; cdot\; 10^\{2\; cdot\; m\}(z\_1\; -\; z\_2\; -\; z\_0)\; cdot\; 10^m\; z\_0$$hasil= z2​⋅102⋅m (z1​ −z2​ −z0​ )⋅10m z0​
   di mana $(m)$(m) ialah separuh daripada bilangan digit dalam nombor asal.

Pendekatan ini mengurangkan bilangan pendaraban rekursif daripada empat kepada tiga, meningkatkan kecekapan.

---

Pelaksanaan JavaScript

Di bawah ialah pelaksanaan teguh algoritma Karatsuba dalam JavaScript. Versi ini menyokong integer yang besar sewenang-wenangnya dengan mewakilinya sebagai rentetan.

darab.js

/**
 * Karatsuba multiplication algorithm for large numbers.
 * @param {string} num1 - First large number as a string.
 * @param {string} num2 - Second large number as a string.
 * @returns {string} - Product of the two numbers as a string.
 */
function karatsubaMultiply(num1, num2) {
  // Remove leading zeros
  num1 = num1.replace(/^0+/, "") || "0";
  num2 = num2.replace(/^0+/, "") || "0";

  // If either number is zero, return "0"
  if (num1 === "0" || num2 === "0") return "0";

  // Base case for small numbers (12), use Number for safe multiplication
  if (num1.length = 0; i--) {
      const sum = parseInt(a[i]) + parseInt(b[i]) + carry;
      result = (sum % 10) + result;
      carry = Math.floor(sum / 10);
    }

    if (carry > 0) {
      result = carry + result;
    }

    return result.replace(/^0+/, "") || "0";
  }

  // Helper function to multiply by 10^n
  function multiplyByPowerOf10(num, power) {
    return num === "0" ? "0" : num + "0".repeat(power);
  }

  // Helper function for subtracting large numbers
  function subtractLargeNumbers(a, b) {
    const maxLength = Math.max(a.length, b.length);
    a = a.padStart(maxLength, "0");
    b = b.padStart(maxLength, "0");

    let result = "";
    let borrow = 0;

    for (let i = maxLength - 1; i >= 0; i--) {
      let diff = parseInt(a[i]) - parseInt(b[i]) - borrow;
      if (diff 





<pre class="brush:php;toolbar:false">node multiply.js

---

Ciri Utama Pelaksanaan

1. Pengoptimuman Kes Asas:

   • Untuk nombor sehingga 12 digit, algoritma secara langsung menggunakan Nombor JavaScript untuk pendaraban yang cekap.

2. Manipulasi Rentetan untuk Ketepatan Arbitrari:

   • Algoritma menggunakan operasi rentetan untuk mengendalikan nombor yang besar tanpa kehilangan ketepatan.

3. Fungsi Pembantu:

   • Tambahan (addLargeNumbers): Mengendalikan penambahan dua nombor besar yang diwakili sebagai rentetan.
   • Penolakan (tolakNombor Besar): Menguruskan penolakan dengan meminjam nombor besar.
   • Kuasa 10 Pendaraban (darabByPowerOf10): Mengalih nombor dengan cekap dengan menambahkan sifar.

4. Reka Bentuk Rekursif:

   • Algoritma membahagikan setiap input secara rekursif, menggabungkan hasil menggunakan formula Karatsuba.

---

Pertimbangan Prestasi

Algoritma Karatsuba mengurangkan bilangan pendaraban rekursif daripada $(O(n^2))$(O(n2)) kepada lebih kurang $(O(n^{1.585}))$(O(n1.585)) . Ini menjadikannya lebih pantas daripada kaedah tradisional untuk input besar. Walau bagaimanapun, overhed manipulasi rentetan boleh menjejaskan prestasi untuk input yang lebih kecil, itulah sebabnya pengoptimuman kes asas adalah penting.

---

Contoh Output

Untuk:

/**
 * Karatsuba multiplication algorithm for large numbers.
 * @param {string} num1 - First large number as a string.
 * @param {string} num2 - Second large number as a string.
 * @returns {string} - Product of the two numbers as a string.
 */
function karatsubaMultiply(num1, num2) {
  // Remove leading zeros
  num1 = num1.replace(/^0+/, "") || "0";
  num2 = num2.replace(/^0+/, "") || "0";

  // If either number is zero, return "0"
  if (num1 === "0" || num2 === "0") return "0";

  // Base case for small numbers (12), use Number for safe multiplication
  if (num1.length = 0; i--) {
      const sum = parseInt(a[i]) + parseInt(b[i]) + carry;
      result = (sum % 10) + result;
      carry = Math.floor(sum / 10);
    }

    if (carry > 0) {
      result = carry + result;
    }

    return result.replace(/^0+/, "") || "0";
  }

  // Helper function to multiply by 10^n
  function multiplyByPowerOf10(num, power) {
    return num === "0" ? "0" : num + "0".repeat(power);
  }

  // Helper function for subtracting large numbers
  function subtractLargeNumbers(a, b) {
    const maxLength = Math.max(a.length, b.length);
    a = a.padStart(maxLength, "0");
    b = b.padStart(maxLength, "0");

    let result = "";
    let borrow = 0;

    for (let i = maxLength - 1; i >= 0; i--) {
      let diff = parseInt(a[i]) - parseInt(b[i]) - borrow;
      if (diff 



<p>Hasilnya ialah:<br>
</p>

<pre class="brush:php;toolbar:false">node multiply.js

---

Kesimpulan

Algoritma pendaraban Karatsuba ialah penyelesaian yang praktikal dan cekap untuk mendarab nombor besar. Pelaksanaan ini menunjukkan kuasa dan fleksibilitinya apabila mengendalikan input besar secara sewenang-wenangnya dalam JavaScript. Dengan keperluan yang semakin meningkat untuk aritmetik berketepatan tinggi, menguasai algoritma sedemikian boleh meningkatkan keupayaan pengiraan dalam pelbagai aplikasi.

Atas ialah kandungan terperinci Memahami dan Melaksanakan Algoritma Pendaraban Karatsuba untuk Nombor Besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!