ARRAY REVERSE IN C/C++/JAVA/PYTHON/JAVASCRIPT - TECHCODEVIEW.COM

Array käänteinen tai kääntää matriisin tarkoittaa tietyn taulukon kunkin luvun muuttamista sen vastakkaiseen paikkaan lopusta, eli jos luku on paikassa 1, sen uusi sijainti on Array.length, samoin jos numero on paikassa 2, sen uusi sijainti on Array.length – 1 ja niin edelleen.

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

Kun taulukko (tai merkkijono) on annettu, tehtävänä on kääntää taulukko/merkkijono.

Esimerkkejä:

Syöte: alkuperäinen_taulukko[] = {1, 2, 3} Lähtö: taulukko_käänteinen[] = {3, 2, 1}

Syöte: alkuperäinen_taulukko[] = {4, 5, 1, 2}
Lähtö: taulukko_käänteinen[] = {2, 1, 5, 4}

Sisällysluettelo

1. Matriisi käänteinen käyttämällä ylimääräistä taulukkoa (ei paikallaan):
2. Matriisi käänteinen käyttämällä silmukkaa (paikallaan):
3. Käänteiset sisäänrakennetut menetelmät (ei paikallaan):
4. Ryhmän käänteinen rekursio (paikallinen tai ei-paikallinen):
5. Ryhmän käänteinen pino (ei paikallaan):

1. Array Reverse Ylimääräisen taulukon käyttäminen (ei paikallaan):

Luo uusi taulukko, joka on samankokoinen kuin alkuperäinen taulukko.
Kopioi elementit alkuperäisestä taulukosta uuteen taulukkoon käänteisessä järjestyksessä.

Alla on yllä olevan lähestymistavan toteutus:

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 + ' ')); } // Käyttöesimerkki: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(alkuperäinenArr);>>  
  Lähtö  Reversed Array: 5 4 3 2 1>
      Aika monimutkaisuus:    Päällä)Elementtien kopioiminen uuteen taulukkoon on lineaarinen operaatio.
    Aputilan monimutkaisuus:    Päällä)Lisätilaa käytetään uuden taulukon tallentamiseen.
2. Array Reverse    Silmukan käyttäminen (paikallisesti):    
Iteroi taulukon läpi käyttämällä kaksi osoitinta (alku ja loppu).
Vaihda elementtejä aloitus- ja loppuosoittimissa.
Siirrä aloitusosoitinta kohti loppua ja loppuosoitinta kohti alkua, kunnes ne kohtaavat tai risteävät.
 
 Alla on yllä olevan lähestymistavan toteutus:
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  ?>>>  
  Lähtö      Aika monimutkaisuus:    Päällä)Silmukka kulkee puolet taulukosta, joten se on lineaarinen taulukon koon suhteen.
    Aputilan monimutkaisuus:    O(1)Paikalla oleva kääntö, eli se ei käytä lisätilaa.
    3. Käänteiset sisäänrakennetut menetelmät (ei paikallaan):    
Käytä sisäänrakennettuja menetelmiä, kutenreverse>Pythonissa taiArray.Reverse>C#:ssa.
Alla on yllä olevan lähestymistavan toteutus:
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);>
   
  Lähtö      Aika monimutkaisuus:    O(n) Thereverse>menetelmällä on tyypillisesti lineaarinen aikamonimutkaisuus.    Aputilan monimutkaisuus:    Päällä)Lisätilaa käytetään käänteisen taulukon tallentamiseen.
    4. Ryhmän käänteinen rekursio (paikallinen tai ei-paikallinen):    
Määrittele rekursiivinen funktio, joka ottaa syötteenä taulukon.
Vaihda ensimmäinen ja viimeinen elementti.
Kutsu rekursiivisesti funktiota jäljellä olevan alitaulukon kanssa.
Alla on yllä olevan lähestymistavan toteutus:
alkuluku 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>= loppu) paluu;  int temp = arr[aloitus];  arr[aloitus] = arr[loppu];  arr[end] = lämpötila;  // Rekursiivinen funktio kutsuu reverseArray(arr, alku + 1, loppu - 1); } /* Aputoiminto taulukon tulostamiseen */ 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>= loppu) paluu;  temp = arr[aloitus];  arr[aloitus] = arr[loppu];  arr[end] = lämpötila;  reverseArray(arr, alku + 1, loppu - 1); } /* Apuohjelma, joka tulostaa taulukon riville */ 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 };  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>= loppu) paluu;  temp = arr[aloitus];  arr[aloitus] = arr[loppu];  arr[end] = lämpötila;  reverseArray(arr, alku + 1, loppu - 1);  } /* Apuohjelma, joka tulostaa taulukon riville */ 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>= loppu: paluu A[alku], A[loppu] = A[loppu], A[aloitus] reverseList(A, alku+1, loppu-1) # Testattava ohjaintoiminto A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Käänteinen lista on') print(A) # Tämän ohjelman on tuottanut 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>= loppu) paluu;  temp = arr[aloitus];  arr[aloitus] = arr[loppu];  arr[end] = lämpötila;  reverseArray(arr, alku + 1, loppu - 1);  } /* Apuohjelma, joka tulostaa taulukon riville */ 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>= $loppu) { paluu; } $lämpö = $arr[$aloitus]; $arr[$aloitus] = $arr[$loppu]; $arr[$end] = $lämpötila; // Rekursiivinen funktio kutsuu reverseArray($arr, $aloitus + 1, $end - 1); } /* Aputoiminto taulukon tulostamiseen */ 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); ?>>>  
  Lähtö  1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1>
      Aika monimutkaisuus:    Päällä). Rekursio kulkee jokaisen elementin läpi kerran, joten se on lineaarinen.
    Aputilan monimutkaisuus:    O(n) ei-in-place, O(log n) paikallaan (johtuen rekursiopinosta).
    5. Ryhmän käänteinen pino (ei paikallaan):    
Työnnä jokainen taulukon elementti pinoon.
Pop elementtejä pinosta muodostaaksesi käänteisen taulukon.
Alla on yllä olevan lähestymistavan toteutus:
C++ #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack pino;  // Työnnä elementit pinoon varten (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('Pinon ylivuoto
');  palata;  } pino->arr[++pino->top] = elementti; } int pop(rakenne Pino* pino) { if (pino->top == -1) { printf('Pinon alivirtaus
');  poistu(1);  } return pino->arr[pino->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Pino pino;  pino.top = -1;  // Työnnä elementit pinoon varten (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 pino = new Pino();  // Työnnä elementit pinoon for (int elementti : arr) { pino.push(element);  } // Pop elementtejä pinosta kääntääksesi taulukon (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 pino = uusi pino ();  // Työnnä elementit pinoon foreach(int element in arr) { pino.Push(element); } // Pop elementtejä pinosta kääntääksesi taulukon (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);>
   
  Lähtö      Aika monimutkaisuus:    Päällä)Kunkin elementin työntäminen pinoon/pinosta irrottaminen vaatii lineaarista aikaa.
    Aputilan monimutkaisuus:    Päällä)Lisätilaa käytetään pinon säilyttämiseen.
6. Kahden osoittimen lähestymistapa
Aseta alkuun 0 ja lopuksi koko – 1.
Vaihda elementtejä, kunnes osoittimet kohtaavat: Kun alku on pienempi kuin loppu, vaihda arr[alku] ja arr[end].
Vaihda arr[alku] arvolla arr[end].
Lisäyksen alku ja pienennys loppu.
Jatka osoittimien vaihtamista ja siirtämistä, kunnes aloitusristikko päättyy.
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>
      Lähtö:    
 Reversed Array: 5 4 3 2 1>
    Aika monimutkaisuus:    O(n) – Tämä algoritmi toistuu taulukon läpi kerran ja suorittaa kullekin elementille vakiomäärän operaatioita, mikä johtaa lineaariseen aikamonimutkaisuuteen.
     Tilan monimutkaisuus:    O(1) – Algoritmi kääntää taulukon paikalleen ilman lisätietorakenteita, mikä vaatii vakiotilaa syötetaulukon koosta riippumatta.