logo

TechCodeview

Array Reverse în C/C++/Java/Python/JavaScript

Matrice inversă sau inversează o matrice înseamnă schimbarea poziției fiecărui număr al matricei date în poziția sa opusă față de sfârșit, adică dacă un număr este la poziția 1, atunci noua sa poziție va fi Array.length, în mod similar, dacă un număr se află la poziția 2, atunci noua sa poziție va fi Array.length – 1 și așa mai departe.

Array Reverse în C/C++/Java/Python/JavaScript

Având în vedere o matrice (sau șir), sarcina este de a inversa matricea/șirul.



Exemple:

Intrare: original_array[] = {1, 2, 3} Ieșire: array_reversed[] = {3, 2, 1}

Intrare: matrice_original[] = {4, 5, 1, 2}
Ieșire: array_reversed[] = {2, 1, 5, 4}

Cuprins

1. Array Reverse Folosind o matrice suplimentară (non-in-place):

  • Creați o nouă matrice de aceeași dimensiune ca și matricea originală.
  • Copiați elementele din tabloul original în noua matrice în ordine inversă.

Mai jos este implementarea abordării de mai sus:

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); }>
C 
#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);  } }>
Piton 
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)>
C# 
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 =>proces.stdout.write(element + ' ')); } // Exemplu de utilizare: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);>>>  
  Ieșire  
Reversed Array: 5 4 3 2 1>
  
  •     Complexitatea timpului:    Pe)
    • Copierea elementelor într-o nouă matrice este o operație liniară.
  •     Complexitatea spațiului auxiliar:    Pe)
    • Spațiul suplimentar este utilizat pentru a stoca noua matrice.
2. Array Reverse    Utilizarea unei bucle (la loc):    
  • Iterați prin matrice folosind două indicatoare (început și sfârșit).
  • Schimbați elementele de la indicatorul de început și de final.
  • Mutați indicatorul de început spre sfârșit și indicatorul de final spre început până când se întâlnesc sau se încrucișează.
 inversa-un-numar
 
Mai jos este implementarea abordării de mai sus:
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; }>
 C 
// 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);   }  }>
 Piton 
# 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>
 C# 
// 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  ?>>>>  
  Ieșire      Complexitatea timpului:    Pe)
  • Bucla trece prin jumătate din matrice, deci este liniară în raport cu dimensiunea matricei.
  •     Complexitatea spațiului auxiliar:    O(1)
    • Inversare pe loc, ceea ce înseamnă că nu utilizează spațiu suplimentar.
    •     3. Metode integrate inverse ale matricei (non-place):    
    • Utilizați metode încorporate precumreverse>în Python sauArray.Reverse>în C#.
    Mai jos este implementarea abordării de mai sus:
    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));  } }>
         Piton 
    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)>
         C# 
    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);>
           
      Ieșire      Complexitatea timpului:    Pereverse>metoda are de obicei complexitate liniară în timp.
  •     Complexitatea spațiului auxiliar:    Pe)
    • Spațiul suplimentar este utilizat pentru a stoca matricea inversată.
    •     4. Recursie inversă a matricei (in loc sau non-la loc):    
    • Definiți o funcție recursivă care ia ca intrare o matrice.
    • Schimbați primul și ultimul element.
    • Apelați recursiv funcția cu subbarraul rămas.
    Mai jos este implementarea abordării de mai sus:
    caracter în int java

    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>= sfârşit) întoarcere;  int temp = arr[start];  arr[start] = arr[sfârșit];  arr[end] = temp;  // Functie recursiva care apeleaza reverseArray(arr, start + 1, end - 1); } /* Funcție utilitar pentru a tipări o matrice */ 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; }>
         C 
    // 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>= sfârşit) întoarcere;  temp = arr[start];  arr[start] = arr[sfârșit];  arr[end] = temp;  reverseArray(arr, start + 1, end - 1); } /* Utilitar care tipărește o matrice pe o linie */ void printArray(int arr[], int size) { int i;  pentru (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 };  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>= sfârşit) întoarcere;  temp = arr[start];  arr[start] = arr[sfârșit];  arr[end] = temp;  reverseArray(arr, start + 1, end - 1);  } /* Utilitar care tipărește o matrice pe o linie */ 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*/>
         Piton 
    # Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= final: return A[start], A[end] = A[end], A[start] reverseList(A, start+1, end-1) # Funcția driver de testat deasupra funcției A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Lista inversată este') print(A) # Acest program este contribuit de Pratik Chhajer>
         C# 
    // 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>= sfârşit) întoarcere;  temp = arr[start];  arr[start] = arr[sfârșit];  arr[end] = temp;  reverseArray(arr, start + 1, end - 1);  } /* Utilitar care tipărește o matrice pe o linie */ 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>= $end) { return; } $temp = $arr[$start]; $arr[$start] = $arr[$end]; $arr[$end] = $temp; // Functie recursiva care apeleaza reverseArray($arr, $start + 1, $end - 1); } /* Funcție utilitar pentru a imprima o matrice */ 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); ?>>>>  
      Ieșire  
    1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1>
          
    •     Complexitatea timpului:    Pe). Recursiunea trece prin fiecare element o dată, deci este liniară.
    •     Complexitatea spațiului auxiliar:    O(n) pentru non-in-place, O(log n) pentru in-place (datorită stivei recursive).
        5. Stivă inversă a matricei (non pe loc):    
    • Împingeți fiecare element al matricei pe o stivă.
    • Scoateți elementele din stivă pentru a forma matricea inversată.
    Mai jos este implementarea abordării de mai sus:
    C++ 
    #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack grămadă;  // Împingeți elementele pe stivă pentru (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
');  întoarcere;  } stack->arr[++stack->top] = element; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  ieșire(1);  } return stivă->arr[stivă->sus--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack stack;  stack.top = -1;  // Împingeți elementele pe stivă pentru (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 stivă = stivă nouă();  // Împinge elementele pe stivă pentru (int element : arr) { stack.push(element);  } // Scoate elemente din stivă pentru a inversa matricea pentru (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 + ' ');  }  } }>
         Piton 
    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 stivă = stivă nouă ();  // Împinge elementele pe stivă foreach(int element in arr) { stack.Push(element); } // Ieșiți elemente din stivă pentru a inversa matricea pentru (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);>
           
      Ieșire      Complexitatea timpului:    Pe)
    • Împingerea și împingerea fiecărui element pe/din stivă necesită timp liniar.
  •     Complexitatea spațiului auxiliar:    Pe)
    • Spațiul suplimentar este utilizat pentru depozitarea stivei.
    • 6. Abordare cu două puncte
    • Setați începutul la 0 și sfârșitul la dimensiunea – 1.
    • Schimbați elementele până când indicatorii se întâlnesc: în timp ce începutul este mai mic decât finalul, schimbați arr[start] cu arr[end].
    • Schimbați arr[start] cu arr[end].
    • Crește începutul și scade sfârșitul.
    • Continuați să schimbați și să mutați pointerii până la sfârșitul crucilor de început.
    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>
          
        Ieșire:    
     
    Reversed Array: 5 4 3 2 1>
        Complexitatea timpului:    O(n) – Acest algoritm iterează prin matrice o dată, efectuând un număr constant de operații pentru fiecare element, rezultând o complexitate liniară de timp.
     
        Complexitatea spațiului:    O(1) – Algoritmul inversează matricea în loc fără a utiliza structuri de date suplimentare, necesitând astfel spațiu constant, indiferent de dimensiunea matricei de intrare.