ARRAY OMKEREN IN C/C++/JAVA/PYTHON/JAVASCRIPT

Array omgekeerd of een array omkeren betekent het veranderen van de positie van elk nummer van de gegeven array naar de tegenovergestelde positie vanaf het einde, dat wil zeggen als een nummer zich op positie 1 bevindt, dan zal de nieuwe positie Array.length zijn, op dezelfde manier als een nummer zich op positie 2 bevindt, zal de nieuwe positie zijn Array.length – 1, enzovoort.

Array omkeren in C/C++/Java/Python/JavaScript

Gegeven een array (of string), is het de taak om de array/string om te keren.

Voorbeelden:

Invoer: originele_array[] = {1, 2, 3} Uitgang: array_reversed[] = {3, 2, 1}

Invoer: originele_array[] = {4, 5, 1, 2}
Uitgang: array_reversed[] = {2, 1, 5, 4}

Inhoudsopgave

1. Array omkeren met behulp van een extra array (niet op zijn plaats):
2. Array omkeren met behulp van een lus (in-place):
3. Array omgekeerde ingebouwde methoden (niet ter plaatse):
4. Array omgekeerde recursie (in-place of niet-in-place):
5. Array omgekeerde stapel (niet op zijn plaats):

1. Array omkeren Een extra array gebruiken (niet ter plaatse):

Maak een nieuwe array van dezelfde grootte als de originele array.
Kopieer elementen van de oorspronkelijke array naar de nieuwe array in omgekeerde volgorde.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++

  #include ; using namespace std; void reverseArrayExtraArray(int arr[], int size) {  int reversedArr[size];  for (int i = 0; i  < size; i++) {  reversedArr[i] = arr[size - i - 1];  }  // Print reversed array  cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < reversedArr[i]  < < ' ';  } } int main() {  int originalArr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(originalArr) / sizeof(originalArr[0]);  reverseArrayExtraArray(originalArr, size); }

  #include  void reverseArrayExtraArray(int arr[], int size) {  int reversedArr[size];  for (int i = 0; i  < size; i++) {  reversedArr[i] = arr[size - i - 1];  }  // Print reversed array  printf('Reversed Array: ');  for (int i = 0; i  < size; i++) {  printf('%d ', reversedArr[i]);  } } int main() {  int originalArr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(originalArr) / sizeof(originalArr[0]);  reverseArrayExtraArray(originalArr, size);  return 0; }

Java

  /*package whatever //do not write package name here */ import java.io.*; public class ReverseArrayExtraArray {  public static void reverseArrayExtraArray(int[] arr)  {  int[] reversedArr = new int[arr.length];  for (int i = 0; i  < arr.length; i++) {  reversedArr[i] = arr[arr.length - i - 1];  }  // Print reversed array  System.out.print('Reversed Array: ');  for (int i : reversedArr) {  System.out.print(i + ' ');  }  }  public static void main(String[] args)  {  int[] originalArr = { 1, 2, 3, 4, 5 };  reverseArrayExtraArray(originalArr);  } }

Python

  def reverse_array_extra_array(arr): reversed_arr = arr[::-1] # Print reversed array print('Reversed Array:', end=' ') for i in reversed_arr: print(i, end=' ') # Example usage: original_arr = [1, 2, 3, 4, 5] reverse_array_extra_array(original_arr)

  using System; class Program {  static void ReverseArrayExtraArray(int[] arr) {  int[] reversedArr = new int[arr.Length];  for (int i = 0; i  < arr.Length; i++) {  reversedArr[i] = arr[arr.Length - i - 1];  }  // Print reversed array  Console.Write('Reversed Array: ');  foreach (int num in reversedArr) {  Console.Write(num + ' ');  }  }  static void Main() {  int[] originalArr = {1, 2, 3, 4, 5};  ReverseArrayExtraArray(originalArr);  } }

JavaScript

  function reverseArrayExtraArray(arr) {  const reversedArr = arr.slice().reverse();  // Print reversed array  process.stdout.write('Reversed Array: ');  reversedArr.forEach(element =>process.stdout.write(element + '')); } // Voorbeeldgebruik: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(origineleArr);

Uitvoer

Reversed Array: 5 4 3 2 1

Tijdcomplexiteit: Op)
- Het kopiëren van elementen naar een nieuwe array is een lineaire bewerking.
Complexiteit van de hulpruimte: Op)
- Er wordt extra ruimte gebruikt om de nieuwe array op te slaan.

2. Array omkeren Een lus gebruiken (ter plaatse):

Doorloop de array met behulp van twee wijzers (begin en einde).
Verwissel elementen bij de begin- en eindaanwijzers.
Verplaats de startwijzer naar het einde en de eindwijzer naar het begin totdat ze elkaar ontmoeten of kruisen.

omgekeerd-een-nummer

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++

  // Iterative C++ program to reverse an array #include ; using namespace std; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  while (start  < end) {  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  } } /* Utility function to print an array */ void printArray(int arr[], int size) {  for (int i = 0; i  < size; i++)  cout  < < arr[i]  < < ' ';  cout  < < endl; } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  // To print original array  printArray(arr, n);  // Function calling  reverseArray(arr, 0, n - 1);  cout  < < 'Reversed array is'  < < endl;  // To print the Reversed array  printArray(arr, n);  return 0; }

  // Iterative C program to reverse an array #include  /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  int temp;  while (start  < end) {  temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  } } /* Utility that prints out an array on a line */ void printArray(int arr[], int size) {  int i;  for (i = 0; i  < size; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  printArray(arr, n);  reverseArray(arr, 0, n - 1);  printf('Reversed array is 
');  printArray(arr, n);  return 0; }

Java

  public class GFG {   /* Function to reverse arr[] from start to end*/  static void reverseArray(int arr[], int start, int end) {   int temp;   while (start  < end) {   temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;   start++;   end--;   }   }   /* Utility that prints out an array on a line */  static void printArray(int arr[], int size) {   for (int i = 0; i  < size; i++)   System.out.print(arr[i] + ' ');   System.out.println();   }   // Driver code   public static void main(String args[]) {   int arr[] = {1, 2, 3, 4, 5, 6};   printArray(arr, 6);   reverseArray(arr, 0, 5);   System.out.print('Reversed array is 
');   printArray(arr, 6);   }  }

Python

  # Iterative python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): while start  < end: A[start], A[end] = A[end], A[start] start += 1 end -= 1 # Driver function to test above function A = [1, 2, 3, 4, 5, 6] print(A) reverseList(A, 0, 5) print('Reversed list is') print(A) # This program is contributed by Pratik Chhajer

  // Iterative C# program to reverse an // array using System; class GFG {  /* Function to reverse arr[] from  start to end*/  static void reverseArray(int[] arr, int start, int end)  {  int temp;  while (start  < end) {  temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  }  }  /* Utility that prints out an  array on a line */  static void printArray(int[] arr, int size)  {  for (int i = 0; i  < size; i++)  Console.Write(arr[i] + ' ');  Console.WriteLine();  }  // Driver function  public static void Main()  {  int[] arr = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  Console.Write('Reversed array is 
');  printArray(arr, 6);  } } // This code is contributed by Sam007

JavaScript

  // Iterative Javascript program to reverse an array  /* Function to reverse arr[] from start to end*/ function reverseArray(arr,start,end)  {   while (start  < end)   {   var temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;   start++;   end--;   }  }  /* Utility function to print an array */ function printArray(arr,size)  {  for (var i = 0; i  < size; i++){  console.log(arr[i]);  }  }  /* Driver function to test above functions */  var arr= [1, 2, 3, 4, 5, 6];   var n = 6;   // To print original array   printArray(arr, n);     // Function calling   reverseArray(arr, 0, n-1);     console.log('Reversed array is');   printArray(arr, n);

PHP

   // Iterative PHP program  // to reverse an array  /* Function to reverse  $arr from start to end*/ function reverseArray(&$arr, $start, $end) { while ($start  < $end) { $temp = $arr[$start]; $arr[$start] = $arr[$end]; $arr[$end] = $temp; $start++; $end--; } } /* Utility function to  print an array */ function printArray(&$arr, $size) { for ($i = 0; $i  < $size; $i++) echo $arr[$i] . ' '; echo '
'; } // Driver code  $arr = array(1, 2, 3, 4, 5, 6); // To print original array  printArray($arr, 6); // Function calling  reverseArray($arr, 0, 5); echo 'Reversed array is' .'
'; // To print the Reversed array  printArray($arr, 6); // This code is contributed  // by ChitraNayal  ?>

Uitvoer

1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1

Tijdcomplexiteit: Op)
- De lus loopt door de helft van de array en is dus lineair ten opzichte van de arraygrootte.
Complexiteit van de hulpruimte: O(1)
- Omkering ter plaatse, wat betekent dat er geen extra ruimte wordt gebruikt.

3. Array omgekeerde ingebouwde methoden (niet ter plaatse):

Gebruik ingebouwde methoden zoals reverse> in Python of Array.Reverse> in C#.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++

  #include  // for std::reverse #include  int main() {  int originalArray[] = { 1, 2, 3, 4, 5 };  int length  = sizeof(originalArray) / sizeof(originalArray[0]);  // Using inbuilt method in C++  std::reverse(originalArray, originalArray + length);  // Print the reversed array  for (int i = 0; i  < length; i++) {  std::cout  < < originalArray[i]  < < ' ';  }  return 0; }

Java

  /*package whatever //do not write package name here */ import java.util.Arrays; public class ArrayReverse {  public static void main(String[] args)  {  int[] originalArray = { 1, 2, 3, 4, 5 };  // Using inbuilt method in Java  int[] reversedArray = new int[originalArray.length];  for (int i = 0; i  < originalArray.length; i++) {  reversedArray[i]  = originalArray[originalArray.length - 1  - i];  }  // Print the reversed array  System.out.println(Arrays.toString(reversedArray));  } }

Python

  original_array = [1, 2, 3, 4, 5] # Using inbuilt method in Python reversed_array = list(reversed(original_array)) # Print the reversed array print(reversed_array)

  using System; class Program {  static void Main()  {  int[] originalArray = { 1, 2, 3, 4, 5 };  // Using inbuilt method in C#  Array.Reverse(originalArray);  // Print the reversed array  foreach(int num in originalArray)  {  Console.Write(num + ' ');  }  } }

JavaScript

  let originalArray = [1, 2, 3, 4, 5]; // Using inbuilt method in JavaScript let reversedArray = originalArray.slice().reverse(); // Print the reversed array console.log(reversedArray);

Uitvoer

5 4 3 2 1

Tijdcomplexiteit: Op de reverse> methode heeft doorgaans een lineaire tijdscomplexiteit.
Complexiteit van de hulpruimte: Op)
- Extra ruimte wordt gebruikt om de omgekeerde array op te slaan.

4. Array omgekeerde recursie (in-place of niet-in-place):

Definieer een recursieve functie die een array als invoer gebruikt.
Verwissel het eerste en het laatste element.
Roep de functie recursief aan met de resterende subarray.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++

  // Recursive C++ program to reverse an array #include ; using namespace std; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  if (start>= einde) terugkeer;  int temp = arr[start];  arr[start] = arr[eind];  arr[einde] = temperatuur;  // Recursieve functie die reverseArray aanroept (arr, start + 1, end - 1); } /* Hulpprogrammafunctie om een array af te drukken */ void printArray(int arr[], int size) { for (int i = 0; i < size; i++)  cout  < < arr[i]  < < ' ';  cout  < < endl; } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  // To print original array  printArray(arr, 6);  // Function calling  reverseArray(arr, 0, 5);  cout  < < 'Reversed array is'  < < endl;  // To print the Reversed array  printArray(arr, 6);  return 0; }

  // Recursive C program to reverse an array #include ; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  int temp;  if (start>= einde) terugkeer;  temp = arr[start];  arr[start] = arr[eind];  arr[einde] = temperatuur;  reverseArray(arr, begin + 1, einde - 1); } /* Hulpprogramma dat een array op een regel afdrukt */ void printArray(int arr[], int size) { int i;  voor (i = 0; ik < size; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  printf('Reversed array is 
');  printArray(arr, 6);  return 0; }

Java

  /*package whatever //do not write package name here */ import java.io.*; class ReverseArray {  /* Function to reverse arr[] from start to end*/  static void reverseArray(int arr[], int start, int end)  {  int temp;  if (start>= einde) terugkeer;  temp = arr[start];  arr[start] = arr[eind];  arr[einde] = temperatuur;  reverseArray(arr, begin + 1, einde - 1);  } /* Hulpprogramma dat een array op een regel afdrukt */ static void printArray(int arr[], int size) { for (int i = 0; i < size; i++)  System.out.print(arr[i] + ' ');  System.out.println('');  }  /*Driver function to check for above functions*/  public static void main(String[] args)  {  int arr[] = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  System.out.println('Reversed array is ');  printArray(arr, 6);  } } /*This article is contributed by Devesh Agrawal*/

Python

  # Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= end: return A[start], A[end] = A[end], A[start] reverseList(A, start+1, end-1) # Stuurprogrammafunctie om bovenstaande functie te testen A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Omgekeerde lijst is') print(A) # Dit programma is bijgedragen door Pratik Chhajer

  // C# program to reverse an array using System; class GFG {  /* Function to reverse arr[]  from start to end*/  static void reverseArray(int[] arr, int start, int end)  {  int temp;  if (start>= einde) terugkeer;  temp = arr[start];  arr[start] = arr[eind];  arr[einde] = temperatuur;  reverseArray(arr, begin + 1, einde - 1);  } /* Hulpprogramma dat een array op een regel afdrukt */ static void printArray(int[] arr, int size) { for (int i = 0; i < size; i++)  Console.Write(arr[i] + ' ');  Console.WriteLine('');  }  // Driver Code  public static void Main()  {  int[] arr = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  Console.WriteLine('Reversed array is ');  printArray(arr, 6);  } } // This code is contributed by Sam007

JavaScript

// Recursive Javascript program to reverse an array  /* Function to reverse arr[] from start to end*/ function reverseArray(arr,start,end)  {   var temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;    // Recursive Function calling   if (start+1   PHP    // Recursive PHP program to reverse an array /* Function to reverse $arr[] from $start to $end */ function reverseArray(&$arr, $start, $end) { if ($start>= $einde) { return; } $temp = $arr[$start]; $arr[$start] = $arr[$eind]; $arr[$end] = $temp; // Recursieve functie die reverseArray aanroept($arr, $start + 1, $end - 1); } /* Hulpprogrammafunctie om een array af te drukken */ function printArray(&$arr, $size) { for ($i = 0; $i < $size; $i++) { echo $arr[$i] . ' '; } echo '
'; } // Driver function to test above functions $arr = array(1, 2, 3, 4, 5, 6); // To print original array  printArray($arr, 6); // Function calling  reverseArray($arr, 0, 5); echo 'Reversed array is' . '
'; // To print the Reversed array  printArray($arr, 6); ?> 
    
  Uitvoer   1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
       Tijdcomplexiteit:     Op). De recursie doorloopt elk element één keer, dus het is lineair.  
     Complexiteit van de hulpruimte:     O(n) voor niet-in-place, O(log n) voor in-place (vanwege recursiestapel).  
 
     5. Array omgekeerde stapel (niet op zijn plaats):     
   Duw elk element van de array op een stapel.  
  Haal elementen uit de stapel om de omgekeerde array te vormen.  
 
  Hieronder vindt u de implementatie van de bovenstaande aanpak:  
C++   #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack stapel;  // Duw elementen op de stapel voor (int i = 0; i < size; i++) {  stack.push(arr[i]);  }  // Pop elements from the stack to reverse the array  for (int i = 0; i  < size; i++) {  arr[i] = stack.top();  stack.pop();  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayUsingStack(arr, size);  std::cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < arr[i]  < < ' ';  }  return 0; } 
  C   #include ; #include ; #define MAX_SIZE 100 struct Stack {  int arr[MAX_SIZE];  int top; }; void push(struct Stack* stack, int element) {  if (stack->top == MAX_SIZE - 1) { printf('Stack Overflow
');  opbrengst;  } stapel->arr[++stack->top] = element; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  uitgang(1);  } return stapel->arr[stapel->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack-stack;  stapel.top = -1;  // Duw elementen op de stapel voor (int i = 0; i < size; i++) {  push(&stack, arr[i]);  }  // Pop elements from the stack to reverse the array  for (int i = 0; i  < size; i++) {  arr[i] = pop(&stack);  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayUsingStack(arr, size);  printf('Reversed Array: ');  for (int i = 0; i  < size; i++) {  printf('%d ', arr[i]);  }  return 0; } 
  Java   /*package whatever //do not write package name here */ import java.util.Stack; public class ReverseArrayUsingStack {  public static void reverseArrayUsingStack(int[] arr)  {  Stack stapel = nieuwe stapel();  // Duw elementen op de stapel voor (int element: arr) {stack.push(element);  } // Haal elementen uit de stapel om de array om te keren (int i = 0; i < arr.length; i++) {  arr[i] = stack.pop();  }  }  public static void main(String[] args)  {  int[] arr = { 1, 2, 3, 4, 5 };  reverseArrayUsingStack(arr);  System.out.print('Reversed Array: ');  for (int element : arr) {  System.out.print(element + ' ');  }  } } 
  Python   def reverse_array_using_stack(arr): stack = [] # Push elements onto the stack for element in arr: stack.append(element) # Pop elements from the stack to reverse the array for i in range(len(arr)): arr[i] = stack.pop() # Example usage: arr = [1, 2, 3, 4, 5] reverse_array_using_stack(arr) print('Reversed Array:', arr) 
  C#   using System; using System.Collections.Generic; class Program {  static void ReverseArrayUsingStack(int[] arr)  {  Stack stapel = nieuwe stapel ();  // Duw elementen op de stapel foreach(int element in arr) {stack.Push(element); } // Haal elementen uit de stapel om de array om te keren (int i = 0; i < arr.Length; i++) {  arr[i] = stack.Pop();  }  }  static void Main()  {  int[] arr = { 1, 2, 3, 4, 5 };  ReverseArrayUsingStack(arr);  Console.Write('Reversed Array: ');  foreach(int element in arr)  {  Console.Write(element + ' ');  }  } } 
  JavaScript   function reverseArrayUsingStack(arr) {  let stack = [];    // Push elements onto the stack  for (let i = 0; i  < arr.length; i++) {  stack.push(arr[i]);  }  // Pop elements from the stack to reverse the array  for (let i = 0; i  < arr.length; i++) {  arr[i] = stack.pop();  } } // Example usage: let arr = [1, 2, 3, 4, 5]; reverseArrayUsingStack(arr); console.log('Reversed Array:', arr); 
    
  Uitvoer   Reversed Array: 5 4 3 2 1 
       Tijdcomplexiteit:     Op)    Het duwen en laten vallen van elk element op/van de stapel vergt lineaire tijd.  
 
 
     Complexiteit van de hulpruimte:     Op)    Er wordt extra ruimte gebruikt om de stapel op te slaan.  
 
 
 
  6. Tweepuntsbenadering  
   Stel het begin in op 0 en het einde op maat – 1.  
  Wissel elementen om totdat de wijzers elkaar ontmoeten: Terwijl start minder is dan het einde, verwissel je arr[start] met arr[end].  
  Verwissel arr[start] met arr[eind].  
  Start verhogen en einde verlagen.  
  Ga door met het verwisselen en verplaatsen van wijzers totdat het begin het einde kruist.  
 
C++   #include  void reverseArrayTwoPointer(int arr[], int size) {  int start = 0;  int end = size - 1;  while (start  < end) {  // Swap elements at start and end positions  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  // Move start forward and end backward  start++;  end--;  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayTwoPointer(arr, size);  std::cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < arr[i]  < < ' ';  }  return 0; } 
  Java   public class ReverseArray {    public static void reverseArrayTwoPointer(int[] arr) {  int start = 0;  int end = arr.length - 1;  while (start  < end) {  // Swap elements at start and end positions  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  // Move start forward and end backward  start++;  end--;  }  }  public static void main(String[] args) {  int[] arr = { 1, 2, 3, 4, 5 };  reverseArrayTwoPointer(arr);  System.out.print('Reversed Array: ');  for (int i = 0; i  < arr.length; i++) {  System.out.print(arr[i] + ' ');  }  } } // This code is contributed by Shivam 
        Uitgang:     
  Reversed Array: 5 4 3 2 1 
     Tijdcomplexiteit:     O(n) – Dit algoritme itereert één keer door de array en voert een constant aantal bewerkingen uit voor elk element, wat resulteert in lineaire tijdscomplexiteit.  
      Ruimtecomplexiteit:     O(1) – Het algoritme keert de array op zijn plaats om zonder extra datastructuren te gebruiken, waardoor een constante ruimte nodig is, ongeacht de grootte van de invoerarray.