So kehren Sie ein Array in C++, Python und JavaScript um

Eskere Guru

Ein Array ist eine Sammlung von Elementen, die an zusammenhängenden Speicherorten gespeichert sind. Die Umkehrung eines Arrays ist eine der häufigsten Operationen, die an einem Array ausgeführt werden. In diesem Artikel erfahren Sie, wie Sie mit iterativen und rekursiven Ansätzen Ihre eigene Implementierung der Umkehrung eines Arrays schreiben.

Iterativer Ansatz zum Umkehren eines Arrays

Problemstellung

Sie erhalten ein Array arr . Sie müssen die Elemente des Arrays umkehren und dann das umgekehrte Array drucken. Sie müssen diese Lösung mithilfe von Schleifen implementieren.

Beispiel 1 : Sei arr = [45, 12, 67, 63, 9, 23, 74]

Umgekehrter arr = [74, 23, 9, 63, 67, 12, 45]

Die Ausgabe lautet somit: 74 23 9 63 67 12 45.

Beispiel 2 : Sei arr = [1, 2, 3, 4, 5, 6, 7, 8]

Umgekehrter arr = [8, 7, 6, 5, 4, 3, 2, 1]

Die Ausgabe lautet somit: 8 7 6 5 4 3 2 1.

Ansatz zum Umkehren eines Arrays mit Schleifen

Sie können die Elemente eines Arrays mithilfe von Schleifen umkehren, indem Sie dem folgenden Ansatz folgen:

  1. Initialisieren Sie die Indexvariablen "i" und "j" so, dass sie auf den ersten (0) bzw. den letzten (sizeOfArray – 1) Index des Arrays zeigen.
  2. Tauschen Sie in einer Schleife das Element an Index i mit dem Element an Index j aus.
  3. Erhöhen Sie den Wert von i um 1 und verringern Sie den Wert von j um 1.
  4. Führen Sie die Schleife aus, bis i < sizeOfArray/2 ist.

C++-Programm zum Umkehren eines Arrays mit Schleifen

Unten ist das C++-Programm zum Umkehren eines Arrays mit Schleifen:

 // C++ program to reverse the elements of an array using loops
 #include <iostream>
 using namespace std;

 void reverseArr(int arr[], int size)
 {
 for(int i=0, j=size-1; i<size/2; i++, j--)
 {
 swap(arr[i], arr[j]);
 }
 }
 void printArrayElements(int arr[], int size)
 {
 for(int i=0; i<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
 }
 // Driver Code
 int main()
 {
 int arr[] = {45, 12, 67, 63, 9, 23, 74};
 int size = sizeof(arr)/sizeof(arr[0]);
 // Printing the original array
 cout << "Original Array: " << endl;
 printArrayElements(arr, size);
 // Reversing the array
 reverseArr(arr, size);
 // Printing the reversed array
 cout << "Reversed array: " << endl;
 printArrayElements(arr, size);
 return 0;
 }

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

Verwandte: Wie man einen String in C++, Python und JavaScript umkehrt

Python-Programm zum Umkehren eines Arrays mit Schleifen

Unten ist das Python-Programm zum Umkehren eines Arrays mit Schleifen:

 # Python program to reverse the elements of a list using loops
 def reverseList(arr, size):
 i = 0
 j = size-1
 while i<size/2:
 arr[i], arr[j] = arr[j], arr[i]
 i = i + 1
 j = j - 1
 def printListElements(arr, size):
 for i in range(size):
 print(arr[i], end=" ")
 print()
 # Driver Code
 arr = [45, 12, 67, 63, 9, 23, 74]
 size = len(arr)
 # Printing the original array
 print("Original Array:")
 printListElements(arr, size)
 # Reversing the array
 reverseList(arr, size)
 # Printing the reversed array
 print("Reversed Array:")
 printListElements(arr, size)

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

JavaScript-Programm zum Umkehren eines Arrays mit Schleifen

Unten ist das JavaScript-Programm zum Umkehren eines Arrays mit Schleifen:

Verwandte: Eine Einführung in den Merge-Sortieralgorithmus

 // JavaScript program to reverse the elements of an array using loops
 function reverseArr(arr, size) {
 for(let i=0, j=size-1; i<(size)/2; i++, j--) {
 [arr[i], arr[j]] = [arr[j], arr[i]];
 }
 }
 function printArrayElements(arr, size) {
 for(let i=0; i<size; i++) {
 document.write(arr[i] + " ");
 }
 document.write("<br>");
 }
 // Driver Code
 var arr = [45, 12, 67, 63, 9, 23, 74];
 var size = arr.length;
 // Printing the original array
 document.write("Original Array: " + "<br>");
 printArrayElements(arr, size);
 // Reversing the array
 reverseArr(arr, size);
 // Printing the reversed array
 document.write("Reversed Array: " + "<br>");
 printArrayElements(arr, size);

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

Rekursiver Ansatz zum Umkehren eines Arrays

Problemstellung

Sie erhalten ein Array arr . Sie müssen die Elemente des Arrays umkehren und dann das umgekehrte Array drucken. Sie müssen diese Lösung mithilfe von Rekursion implementieren.

Beispiel 1 : Sei arr = [45, 12, 67, 63, 9, 23, 74]

Umgekehrter arr = [74, 23, 9, 63, 67, 12, 45]

Somit beträgt die Ausgabe 74 23 9 63 67 12 45.

Beispiel 2 : Sei arr = [1, 2, 3, 4, 5, 6, 7, 8]

Umgekehrter arr = [8, 7, 6, 5, 4, 3, 2, 1]

Somit ist die Ausgabe 8 7 6 5 4 3 2 1.

Ansatz zum Umkehren eines Arrays mit Rekursion

Sie können die Elemente eines Arrays mithilfe von Rekursion umkehren, indem Sie dem folgenden Ansatz folgen:

  1. Initialisieren Sie Indexvariablen start und end so, dass sie auf den ersten (0) bzw. den letzten (sizeOfArray – 1) Index des Arrays zeigen.
  2. Tauschen Sie das Element am Indexanfang mit dem Element am Index Ende.
  3. Rufen Sie die Umkehrfunktion rekursiv auf. In den Parametern der Umkehrfunktion den Wert von start um 1 erhöhen und den Wert von end um 1 verringern.
  4. Beenden Sie die Rekursion , wenn der Wert des Startvariable größer als oder gleich den Wert des Variable Ende.

C++-Programm zum Umkehren eines Arrays mit Rekursion

Unten ist das C++-Programm zum Umkehren eines Arrays mit Rekursion:

 // C++ program to reverse an array using recursion
 #include <iostream>
 using namespace std;
 void reverseArr(int arr[], int start, int end)
 {
 if (start >= end)
 {
 return;
 }
 swap(arr[start], arr[end]);
 reverseArr(arr, start+1, end-1);
 }
 void printArrayElements(int arr[], int size)
 {
 for(int i=0; i<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
 }
 // Driver Code
 int main()
 {
 int arr[] = {45, 12, 67, 63, 9, 23, 74};
 int size = sizeof(arr)/sizeof(arr[0]);
 // Printing the original array
 cout << "Original Array: " << endl;
 printArrayElements(arr, size);
 // Reversing the array
 reverseArr(arr, 0, size-1);
 // Printing the reversed array
 cout << "Reversed array: " << endl;
 printArrayElements(arr, size);
 return 0;
 }

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

Python-Programm zum Umkehren eines Arrays mit Rekursion

Unten ist das Python-Programm zum Umkehren eines Arrays mit Rekursion:

Verwandte: Dynamische Programmierung: Beispiele, häufige Probleme und Lösungen

 # Python program to reverse an array using recursion
 def reverseList(arr, start, end):
 if start >= end:
 return
 arr[start], arr[end] = arr[end], arr[start]
 reverseList(arr, start+1, end-1)
 def printListElements(arr, size):
 for i in range(size):
 print(arr[i], end=" ")
 print()
 # Driver Code
 arr = [45, 12, 67, 63, 9, 23, 74]
 size = len(arr)
 # Printing the original array
 print("Original Array:")
 printListElements(arr, size)
 # Reversing the array
 reverseList(arr, 0, size-1)
 # Printing the reversed array
 print("Reversed Array:")
 printListElements(arr, size)

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

JavaScript-Programm zum Umkehren eines Arrays mit Rekursion

Unten ist das JavaScript-Programm zum Umkehren eines Arrays mit Rekursion:

Verwandte: So finden Sie die Summe natürlicher Zahlen mit Rekursion

 // JavaScript program to reverse an array using recursion
 function reverseArr(arr, start, end)
 {
 if (start >= end)
 {
 return;
 }
 [arr[start], arr[end]] = [arr[end], arr[start]];
 reverseArr(arr, start+1, end-1);
 }
 function printArrayElements(arr, size)
 {
 for(let i=0; i<size; i++)
 {
 document.write(arr[i] + " ");
 }
 document.write("<br>");
 }
 // Driver Code
 var arr = [45, 12, 67, 63, 9, 23, 74];
 let size = arr.length;
 // Printing the original array
 document.write("Original Array: " + "<br>");
 printArrayElements(arr, size);
 // Reversing the array
 reverseArr(arr, 0, size-1);
 // Printing the reversed array
 document.write("Reversed Array: " + "<br>");
 printArrayElements(arr, size);

Ausgabe:

 Original Array:
 45 12 67 63 9 23 74
 Reversed array:
 74 23 9 63 67 12 45

Verwenden Sie Rekursion, um Probleme zu lösen

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft. Bei der Rekursion wird ein Problem gelöst, indem die Probleme in kleinere, einfachere Versionen ihrer selbst zerlegt werden.

Es gibt viele Vorteile der Rekursion: Der rekursive Code ist kürzer als ein iterativer Code, er kann verwendet werden, um die natürlich rekursiven Probleme zu lösen, er kann in Infix-, Präfix- und Postfix-Auswertungen verwendet werden, Rekursion reduziert die Schreibzeit und reduces Debug-Code usw.

Rekursion ist ein beliebtes Thema von Interviewern in technischen Interviews. Sie müssen über Rekursion Bescheid wissen und wissen, wie Sie sie beim Schreiben von Code verwenden, um der effizienteste Programmierer zu sein, der Sie sein können.