JavaScript-Programm zum Maximieren von Elementen mithilfe eines anderen Arrays

In diesem Artikel implementieren wir ein JavaScript-Programm, um Elemente mithilfe eines anderen Arrays zu maximieren. Wir haben zwei Arrays und müssen einige Elemente aus dem zweiten Array auswählen und die Elemente des ersten Arrays ersetzen. Wir werden den vollständigen Code sehen, der die besprochenen Konzepte implementiert.

Einführung in das Problem

In diesem Problem haben wir zwei Arrays und müssen alle Elemente des ersten Arrays so groß wie möglich machen oder einfach die Summe aller Elemente des ersten Arrays so groß wie möglich machen. Wir können Elemente aus dem zweiten Array auswählen, aber der Punkt ist, dass wir ein Element aus dem zweiten Array nur einmal auswählen müssen, danach können wir nur noch ein anderes Element auswählen. Zum Beispiel -

Wir haben zwei Arrays -

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

Wir können sehen, dass viele Elemente im zweiten Array größer sind als die im ersten Array.

Wir können 9 statt 3, 6 statt 2 und 5 statt 1 wählen. Dadurch sieht das endgültige Array so aus -

5 6 9 4 5 

Wir werden zwei Methoden sehen, die beide durch Sortieren eines Arrays und zweier Zeiger implementiert werden, aber der einzige Unterschied besteht darin, wo wir den Zeiger auswählen.

Methode

Wir haben das obige Beispiel gesehen, aus dem wir ersehen können, dass wir die kleinen Elemente im ersten Array mit dem größten Element im zweiten Array austauschen können.

• Schritt 1 – Zuerst sortieren wir beide Arrays in aufsteigender Reihenfolge und kehren dann das zweite Array um, sodass es in absteigender Reihenfolge sortiert wird.

• Schritt 2 – Wir werden zwei Zeiger auf den ersten Index beider Arrays verwalten.

• Schritt 3 – Da der erste Elementzeiger auf die kleinste Zahl zeigt, können wir diese Zahl mit der größten Zahl des zweiten Arrays tauschen.

• Schritt 4 – Bei jeder Iteration tauschen wir die beiden Array-Zeiger aus und erhöhen die Zeiger.

• Schritt 5 – Wenn das Element des aktuellen Index des ersten Arrays im Vergleich zum Element des zweiten Arrays größer wird, können wir weitere Schritte stoppen.

• Schritt 6 – Zum Schluss drucken wir die Elemente des Arrays.

Beispiel

// 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)

Zeitliche und räumliche Komplexität

Die zeitliche Komplexität des obigen Codes beträgt O(N*log(N)), wobei N die Größe des gegebenen Arrays ist und der logarithmische Faktor hier auf die Sortierfunktion zurückzuführen ist, die wir zum Sortieren des Arrays verwenden.

Wir verwenden ein zusätzliches Array zum Speichern der Elemente, wodurch die Raumkomplexität O(N) wird. Das Array wird jedoch zum Speichern seiner Antwort benötigt, was als zusätzlicher Speicherplatz betrachtet werden kann oder auch nicht.

Direkte Sortiermethode

In der vorherigen Methode haben wir die Elemente des Arrays sortiert und dann zwei Zeigermethoden verwendet, aber es gibt eine direkte Methode, mit deren Hilfe wir das einfach machen können -

• Durch die Verwendung der Schlüsselwörter new und Array erstellen wir ein neues Array, dessen Größe der Summe oder Länge der beiden angegebenen Arrays entspricht.

• Wir füllen nacheinander alle Elemente der beiden angegebenen Arrays in das neue Array.

• Wir werden das neu erstellte Array sortieren, um die Elemente in aufsteigender Reihenfolge anzuordnen.

• Alle großartigen Elemente sind am Ende vorhanden und wir können sie leicht erreichen.

Beispiel

// 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)

Zeitliche und räumliche Komplexität

Die zeitliche Komplexität des obigen Codes beträgt O(N*log(N)), wobei N die Größe des gegebenen Arrays ist und der logarithmische Faktor hier auf die Sortierfunktion zurückzuführen ist, die wir zum Sortieren des Arrays verwenden.

Wir verwenden ein zusätzliches Array zum Speichern der Elemente, wodurch die Raumkomplexität O(N) wird.

Fazit

Im obigen Tutorial haben wir ein JavaScript-Programm implementiert, das Elemente mithilfe eines anderen Arrays maximiert. Wir haben zwei Arrays und müssen einige Elemente aus dem zweiten Array auswählen und die Elemente des ersten Arrays ersetzen. Wir haben gesehen, dass beide Methoden das Konzept der Sortierung nutzen. Eine Methode mit zwei Zeigern benötigt O(N*log(N)) Zeit und O(1) Speicherplatz, während die andere Methode die gleiche Zeit, aber O(N) Speicherplatz benötigt.

Das obige ist der detaillierte Inhalt vonJavaScript-Programm zum Maximieren von Elementen mithilfe eines anderen Arrays. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!