logo

TechCodeview

Array Reverse v C/C++/Java/Python/JavaScript

Obratna matrika oz obrniti niz pomeni spremembo položaja vsakega števila dane matrike na njegov nasprotni položaj od konca, tj. če je število na položaju 1, bo njegov novi položaj Array.length, podobno, če je število na položaju 2, bo njegov novi položaj Array.length – 1 in tako naprej.

Array Reverse v C/C++/Java/Python/JavaScript

Glede na matriko (ali niz) je naloga obrniti matriko/niz.



Primeri:

Vnos: originalna_matrika[] = {1, 2, 3} Izhod: array_reversed [] = {3, 2, 1}

Vnos: originalna_matrika[] = {4, 5, 1, 2}
Izhod: array_reversed[] = {2, 1, 5, 4}

Kazalo

1. Array Reverse Uporaba dodatnega niza (ne na mestu):

  • Ustvarite novo matriko enake velikosti kot prvotna matrika.
  • Kopirajte elemente iz prvotne matrike v novo matriko v obratnem vrstnem redu.

Spodaj je izvedba zgornjega pristopa:

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);  } }>
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)>
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 =>process.stdout.write(element + ' ')); } // Primer uporabe: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);>
Izhod 
Reversed Array: 5 4 3 2 1>
  • Časovna zapletenost: O(n)
    • Kopiranje elementov v novo matriko je linearna operacija.
  • Kompleksnost pomožnega prostora: O(n)
    • Za shranjevanje novega polja se uporabi dodaten prostor.

2. Array Reverse Uporaba zanke (na mestu):

  • Iteracija skozi matriko z uporabo dva kazalca (začetek in konec).
  • Zamenjajte elemente na začetnih in končnih kazalcih.
  • Premaknite začetni kazalec proti koncu in končni kazalec proti začetku, dokler se ne srečata ali prekrižata.

obratna številka

Spodaj je izvedba zgornjega pristopa:

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);   }  }>
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>
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  ?>>
Izhod 
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1>
  • Časovna zapletenost: O(n)
    • Zanka poteka skozi polovico matrike, zato je linearna glede na velikost matrike.
  • Kompleksnost pomožnega prostora: O(1)
    • Obračanje na mestu, kar pomeni, da ne uporablja dodatnega prostora.

3. Vgrajene metode Array Reverse (ne na mestu):

  • Uporabite vgrajene metode, kot jereverse>v Pythonu ozArray.Reverse>v C#.

Spodaj je izvedba zgornjega pristopa:

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)>
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);>
Izhod 
5 4 3 2 1>
  • Časovna zapletenost: O(n) Thereverse>metoda ima običajno linearno časovno kompleksnost.
  • Kompleksnost pomožnega prostora: O(n)
    • Dodaten prostor se uporablja za shranjevanje obrnjenega niza.

4. Povratna rekurzija polja (na mestu ali ne na mestu):

  • Definirajte rekurzivno funkcijo, ki sprejme matriko kot vhod.
  • Zamenjaj prvi in ​​zadnji element.
  • Rekurzivno pokličite funkcijo s preostalo podmatriko.

Spodaj je izvedba zgornjega pristopa:

kako preveriti velikost zaslona monitorja
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>= konec) povratek;  int temp = arr[start];  arr[začetek] = arr[konec];  prihod[konec] = temp;  // Rekurzivna funkcija kliče reverseArray(arr, start + 1, end - 1); } /* Pomožna funkcija za tiskanje matrike */ 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>= konec) povratek;  temp = arr[start];  arr[začetek] = arr[konec];  prihod[konec] = temp;  reverseArray(arr, začetek + 1, konec - 1); } /* Pripomoček, ki izpiše matriko v vrstico */ void printArray(int arr[], int size) { int i;  za (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>= konec) povratek;  temp = arr[start];  arr[začetek] = arr[konec];  prihod[konec] = temp;  reverseArray(arr, začetek + 1, konec - 1);  } /* Pripomoček, ki izpiše matriko v vrstico */ 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>= konec: vrni A[začetek], A[konec] = A[konec], A[začetek] reverseList(A, začetek+1, konec-1) # Funkcija gonilnika za preizkus zgornje funkcije A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Obrnjen seznam je') print(A) # Ta program je prispeval 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>= konec) povratek;  temp = arr[start];  arr[začetek] = arr[konec];  prihod[konec] = temp;  reverseArray(arr, začetek + 1, konec - 1);  } /* Pripomoček, ki natisne matriko v vrstico */ 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; // Rekurzivna funkcija kliče reverseArray($arr, $start + 1, $end - 1); } /* Pomožna funkcija za tiskanje matrike */ funkcija 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); ?>>
Izhod 
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1>
  • Časovna zapletenost: O(n). Rekurzija gre skozi vsak element enkrat, zato je linearna.
  • Kompleksnost pomožnega prostora: O(n) za ne-na mestu, O(log n) za na mestu (zaradi rekurzijskega sklada).

5. Povratni sklad matrike (ni na mestu):

  • Vsak element matrike potisnite na sklad.
  • Izstopite elemente iz sklada, da oblikujete obrnjeno matriko.

Spodaj je izvedba zgornjega pristopa:

C++ 
#include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack kup;  // Potisni elemente na sklad za (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
');  vrnitev;  } stack->arr[++stack->top] = element; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  izhod(1);  } return stack->arr[stack->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack stack;  stack.top = -1;  // Potisni elemente na sklad za (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 stack = new Stack();  // Potisni elemente na sklad za (int element : arr) { stack.push(element);  } // Izstopite elemente iz sklada, da obrnete matriko za (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 sklad = nov sklad ();  // Potisni elemente na sklad foreach(int element in arr) { stack.Push(element); } // Izstopite elemente iz sklada, da obrnete matriko za (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);>
Izhod 
Reversed Array: 5 4 3 2 1>
  • Časovna zapletenost: O(n)
    • Potiskanje vsakega elementa na sklad/iz njega zahteva linearni čas.
  • Kompleksnost pomožnega prostora: O(n)
    • Dodaten prostor se uporablja za shranjevanje sklada.

6. Pristop z dvema kazalcema

  • Nastavite začetek na 0 in konec na velikost – 1.
  • Zamenjaj elemente, dokler se kazalci ne srečajo: Medtem ko je začetek manjši od konca, zamenjaj arr[start] z arr[end].
  • Zamenjaj arr[začetek] z arr[konec].
  • Začetek povečanja in konec zmanjšanja.
  • Nadaljujte z zamenjavo in premikanjem kazalcev, dokler začetni križci ne končajo.
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>

Izhod: 

Reversed Array: 5 4 3 2 1>

Časovna zapletenost: O(n) – Ta algoritem enkrat ponovi matriko in izvede konstantno število operacij za vsak element, kar ima za posledico linearno časovno kompleksnost.

Kompleksnost prostora: O(1) – algoritem obrne matriko na mestu brez uporabe kakršnih koli dodatnih podatkovnih struktur, zato zahteva konstanten prostor ne glede na velikost vhodne matrike.