ARRAY INVERSO EN C/C++/JAVA/PYTHON/JAVASCRIPT - TECHCODEVIEW.COM

matriz inversa o invertir una matriz significa cambiar la posición de cada número de la matriz dada a su posición opuesta desde el final, es decir, si un número está en la posición 1, entonces su nueva posición será Array.length, de manera similar, si un número está en la posición 2, entonces su nueva posición será Array.length – 1, y así sucesivamente.

Matriz inversa en C/C++/Java/Python/JavaScript

Dada una matriz (o cadena), la tarea es invertir la matriz/cadena.

Ejemplos:

Aporte: matriz_original[] = {1, 2, 3} Producción: matriz_invertida[] = {3, 2, 1}

Aporte: matriz_original[] = {4, 5, 1, 2}
Producción: matriz_invertida[] = {2, 1, 5, 4}

Tabla de contenidos

1. Inversión de matriz utilizando una matriz adicional (no in situ):
2. Matriz inversa usando un bucle (in situ):
3. Métodos incorporados inversos de matriz (no in situ):
4. Recursión inversa de matriz (in situ o no in situ):
5. Apilamiento inverso de matriz (no in situ):

1. Matriz inversa Usando una matriz adicional (no local):

Cree una nueva matriz del mismo tamaño que la matriz original.
Copie elementos de la matriz original a la nueva matriz en orden inverso.

A continuación se muestra la implementación del enfoque anterior:

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);  } }

Pitón

  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 =>proceso.stdout.write(elemento + ' ')); } // Ejemplo de uso: const originalArr = [1, 2, 3, 4, 5]; ReverseArrayExtraArray(originalArr);

Producción

Reversed Array: 5 4 3 2 1

Complejidad del tiempo: En)
- Copiar elementos a una nueva matriz es una operación lineal.
Complejidad del espacio auxiliar: En)
- Se utiliza espacio adicional para almacenar la nueva matriz.

2. Matriz inversa Usando un bucle (in situ):

Iterar a través de la matriz usando dos consejos (inicio y fin).
Intercambie elementos en los punteros inicial y final.
Mueva el puntero de inicio hacia el final y el puntero de final hacia el inicio hasta que se encuentren o se crucen.

invertir un número

A continuación se muestra la implementación del enfoque anterior:

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);   }  }

Pitón

  # 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  ?>

Producción

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

Complejidad del tiempo: En)
- El bucle recorre la mitad de la matriz, por lo que es lineal con respecto al tamaño de la matriz.
Complejidad del espacio auxiliar: O(1)
- Inversión in situ, lo que significa que no utiliza espacio adicional.

3. Métodos incorporados inversos de matriz (no in situ):

Utilice métodos incorporados como reverse> en Python o Array.Reverse> Cª#.

A continuación se muestra la implementación del enfoque anterior:

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));  } }

Pitón

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

Producción

5 4 3 2 1

Complejidad del tiempo: Sobre el reverse> El método suele tener una complejidad de tiempo lineal.
Complejidad del espacio auxiliar: En)
- Se utiliza espacio adicional para almacenar la matriz invertida.

4. Recursión inversa de matriz (in situ o no in situ):

Defina una función recursiva que tome una matriz como entrada.
Intercambia el primer y el último elemento.
Llame recursivamente a la función con el subconjunto restante.

A continuación se muestra la implementación del enfoque anterior:

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>= fin) regresar;  int temp = arr[inicio];  arreglo[inicio] = arreglo[fin];  llegada[fin] = temporal;  // Función recursiva que llama a ReverseArray(arr, start + 1, end - 1); } /* Función de utilidad para imprimir una matriz */ 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>= fin) regresar;  temp = llegada[inicio];  arreglo[inicio] = arreglo[fin];  llegada[fin] = temporal;  matriz inversa(arr, inicio + 1, final - 1); } /* Utilidad que imprime una matriz en una línea */ void printArray(int arr[], int size) { int i;  para (yo = 0; yo < 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>= fin) regresar;  temp = llegada[inicio];  arreglo[inicio] = arreglo[fin];  llegada[fin] = temporal;  matriz inversa(arr, inicio + 1, final - 1);  } /* Utilidad que imprime una matriz en una línea */ 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*/

Pitón

  # Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= fin: devuelve A[inicio], A[fin] = A[fin], A[inicio] ReverseList(A, inicio+1, fin-1) # Función del controlador para probar la función anterior A = [1, 2, 3 , 4, 5, 6] print(A) ReverseList(A, 0, 5) print('La lista invertida es') print(A) # Este programa es una contribución de 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>= fin) regresar;  temp = llegada[inicio];  arreglo[inicio] = arreglo[fin];  llegada[fin] = temporal;  matriz inversa(arr, inicio + 1, final - 1);  } /* Utilidad que imprime una matriz en una línea */ 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>= $fin) { retorno; } $temp = $arr[$inicio]; $arr[$inicio] = $arr[$end]; $arr[$end] = $temp; // Función recursiva que llama a reverseArray($arr, $start + 1, $end - 1); } /* Función de utilidad para imprimir una matriz */ 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); ?> 
    
  Producción   1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
       Complejidad del tiempo:     En). La recursividad pasa por cada elemento una vez, por lo que es lineal.  
     Complejidad del espacio auxiliar:     O(n) para no in situ, O(log n) para in situ (debido a la pila de recursividad).  
 
     5. Apilamiento inverso de matriz (no in situ):     
   Empuje cada elemento de la matriz en una pila.  
  Extraiga elementos de la pila para formar la matriz invertida.  
 
  A continuación se muestra la implementación del enfoque anterior:  
C++   #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack pila;  // Empuja elementos a la pila para (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->arriba == MAX_SIZE - 1) { printf('Stack Overflow
');  devolver;  } pila->arr[++pila->top] = elemento; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  salir(1);  } return pila->arr[pila->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack stack;  pila.top = -1;  // Empuja elementos a la pila para (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 pila = nueva pila();  // Empuja elementos a la pila for (int elemento: arr) { stack.push(elemento);  } // Extrae elementos de la pila para invertir la matriz para (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 + ' ');  }  } } 
  Pitón   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 pila = nueva pila ();  // Empujar elementos a la pila foreach(int elemento en arr) { stack.Push(elemento); } // Extrae elementos de la pila para invertir la matriz para (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); 
    
  Producción   Reversed Array: 5 4 3 2 1 
       Complejidad del tiempo:     En)    Empujar y sacar cada elemento de la pila requiere un tiempo lineal.  
 
 
     Complejidad del espacio auxiliar:     En)    Se utiliza espacio adicional para almacenar la pila.  
 
 
 
  6.Enfoque de dos punteros  
   Establezca el inicio en 0 y el final en tamaño – 1.  
  Intercambie elementos hasta que los punteros se encuentren: mientras el inicio sea menor que el final, intercambie arr[start] con arr[end].  
  Intercambie arr[inicio] con arr[fin].  
  Inicio del incremento y final del decremento.  
  Continúe intercambiando y moviendo punteros hasta que el inicio cruce el final.  
 
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 
        Producción:     
  Reversed Array: 5 4 3 2 1 
     Complejidad del tiempo:     O(n): este algoritmo recorre la matriz una vez, realizando un número constante de operaciones para cada elemento, lo que da como resultado una complejidad de tiempo lineal.  
      Complejidad espacial:     O(1): el algoritmo invierte la matriz en su lugar sin utilizar estructuras de datos adicionales, por lo que requiere un espacio constante independientemente del tamaño de la matriz de entrada.