Program JavaScript untuk memaksimumkan elemen menggunakan tatasusunan lain

Dalam artikel ini, kami akan melaksanakan program JavaScript untuk memaksimumkan elemen menggunakan tatasusunan lain. Kami mempunyai dua tatasusunan dan perlu memilih beberapa elemen daripada tatasusunan kedua dan menggantikan elemen tatasusunan pertama. Kita akan melihat kod lengkap yang melaksanakan konsep yang akan dibincangkan.

Pengenalan kepada masalah

Dalam masalah ini kita mempunyai dua tatasusunan dan kami perlu menjadikan semua elemen tatasusunan pertama sebagai yang terbesar mungkin atau secara ringkasnya kami perlu menjadikan jumlah semua elemen tatasusunan pertama sebagai terbesar. Kita boleh memilih elemen daripada tatasusunan kedua, tetapi intinya ialah kita perlu memilih elemen daripada tatasusunan kedua sekali sahaja, selepas itu kita hanya boleh memilih elemen lain. Contohnya -

Kami mempunyai dua tatasusunan -

Array1: 1 2 3 4 5 
Array2: 5 6 2 1 9

Kita dapat melihat bahawa banyak elemen dalam tatasusunan kedua adalah lebih besar daripada yang terdapat dalam tatasusunan pertama.

Kita boleh memilih 9 bukannya 3, 6 bukannya 2, dan 5 bukannya 1. Ini menjadikan tatasusunan akhir kelihatan seperti ini -

5 6 9 4 5 

Kita akan melihat dua kaedah, kedua-duanya dilaksanakan dengan menyusun tatasusunan dan dua penunjuk, tetapi satu-satunya perbezaan adalah di mana kita akan memilih penunjuk.

Kaedah

Kita telah melihat contoh di atas, yang mana kita boleh melihat bahawa kita boleh menukar elemen kecil dalam tatasusunan pertama dengan elemen terbesar dalam tatasusunan kedua.

• Langkah 1 - Pertama, kita akan mengisih kedua-dua tatasusunan dalam tertib menaik dan kemudian membalikkan tatasusunan kedua supaya ia diisih dalam tertib menurun.

• Langkah 2 - Kami akan mengekalkan dua penunjuk kepada indeks pertama kedua-dua tatasusunan.

• Langkah 3 - Memandangkan penunjuk elemen pertama akan menunjuk kepada nombor terkecil, kita boleh menukar nombor itu dengan nombor terbesar tatasusunan kedua.

• Langkah 4 - Pada setiap lelaran kita akan menukar dua penunjuk tatasusunan dan menambah penunjuk.

• Langkah 5 - Jika elemen indeks semasa tatasusunan pertama menjadi lebih besar berbanding dengan elemen tatasusunan kedua, maka kita boleh menghentikan langkah selanjutnya.

• Langkah 6 - Akhir sekali, kami akan mencetak elemen tatasusunan.

Contoh

// function to find the maximum array
function maximumArray(array1, array2){
   var len1 = array1.length
   var len2 = array2.length
   
   // sorting the elements of both arrays
   array1.sort()
   array2.sort()
   
   // reversing the arrays
   array1.reverse()
   array2.reverse()
   
   // traversing over the arrays
   var ptr1 = 0
   var ptr2 = 0
   var ptr3 = 0
   
   // creating new array to store the answer
   var ans = new Array(len1);
   while(ptr3 < len1){
      if(ptr2 == len2){
         while(ptr3 != len1){
            ans[ptr3] = array1[ptr1];
            ptr3++;
            ptr1++;
         }
      }
      else if(array1[ptr1] > array2[ptr2]){
         ans[ptr3] = array1[ptr1];
         ptr1++;
      } else {
         ans[ptr3] = array2[ptr2];
         ptr2++;
      }
      ptr3++;
   }
   console.log("The final array is: ")
   console.log(ans)
}
// declaring arrays
array1 = [1, 2, 4, 5, 3]
array2 = [5, 6, 2, 1, 9]

// calling the function
maximumArray(array1,array2)

Kerumitan masa dan ruang

Kerumitan masa kod di atas ialah O(N*log(N)), di mana N ialah saiz tatasusunan yang diberikan dan faktor logaritma di sini adalah disebabkan oleh fungsi pengisihan yang kami gunakan untuk mengisih tatasusunan.

Kami menggunakan tatasusunan tambahan untuk menyimpan elemen, yang menjadikan kerumitan ruang O(N), tetapi tatasusunan diperlukan untuk menyimpan jawapannya, yang mungkin atau mungkin tidak dianggap ruang tambahan.

Kaedah pengisihan terus

Dalam kaedah sebelumnya kami mengisih elemen tatasusunan dan kemudian menggunakan dua kaedah penunjuk, tetapi terdapat kaedah langsung dengan bantuan yang boleh kami lakukan dengan mudah -

• Dengan menggunakan kata kunci baharu dan kata kunci Tatasusunan, kami akan mencipta tatasusunan baharu yang saiznya ialah jumlah atau panjang dua tatasusunan yang diberikan.

• Kami mengisi semua elemen dua tatasusunan yang diberikan ke dalam tatasusunan baharu satu demi satu.

• Kami akan mengisih tatasusunan yang baru dibuat untuk menyusun elemen dalam tertib menaik.

• Semua elemen terhebat hadir pada penghujungnya dan kita boleh mendapatkannya dengan mudah.

Contoh

// function to find the maximum array
function maximumArray(array1, array2){
   var len1 = array1.length
   var len2 = array2.length
   var ans = new Array(len1+len2);
   for(var i = 0; i<len1; i++){
      ans[i] = array1[i];
   }
   for(var i = 0; i< len2; i++){
      ans[i+len1] = array2[i];
   }
   ans.sort();
   for(var i = 0;i<len1;i++){
      array1[i] = ans[len2+len1-i-1];
   }
   console.log("The final array is: ")
   console.log(array1)
}

// declaring arrays
array1 = [1, 2, 4, 5, 3]
array2 = [5, 6, 2, 1, 9]
// calling the function
maximumArray(array1,array2)

Kerumitan masa dan ruang

Kerumitan masa kod di atas ialah O(N*log(N)), di mana N ialah saiz tatasusunan yang diberikan dan faktor logaritma di sini adalah disebabkan oleh fungsi pengisihan yang kami gunakan untuk mengisih tatasusunan.

Kami menggunakan tatasusunan tambahan untuk menyimpan elemen, yang menjadikan kerumitan ruang O(N).

Kesimpulan

Dalam tutorial di atas, kami telah melaksanakan program JavaScript yang memaksimumkan elemen menggunakan tatasusunan lain. Kami mempunyai dua tatasusunan dan perlu memilih beberapa elemen daripada tatasusunan kedua dan menggantikan elemen tatasusunan pertama. Kami telah melihat bahawa kedua-dua kaedah menggunakan konsep pengisihan. Satu kaedah dengan dua penunjuk mengambil masa O(N*log(N)) dan ruang O(1), manakala kaedah lain mengambil masa yang sama tetapi ruang O(N).

Atas ialah kandungan terperinci Program JavaScript untuk memaksimumkan elemen menggunakan tatasusunan lain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!