logo

TechCodeview

Amazonka

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

Pole obráceně nebo obrátit pole znamená změnu pozice každého čísla daného pole na jeho opačnou pozici od konce, tj. pokud je číslo na pozici 1, pak jeho nová pozice bude Array.length, podobně pokud je číslo na pozici 2, bude jeho nová pozice Array.length – 1, a tak dále.

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

Vzhledem k poli (nebo řetězci) je úkolem obrátit pole/řetězec.

Příklady:

Vstup: původní_pole[] = {1, 2, 3} Výstup: pole_obrácené[] = {3, 2, 1}

Vstup: původní_pole[] = {4, 5, 1, 2}
Výstup: array_reversed[] = {2, 1, 5, 4}

Obsah

1. Pole Reverse Použití zvláštního pole (ne na místě):

  • Vytvořte nové pole stejné velikosti jako původní pole.
  • Zkopírujte prvky z původního pole do nového pole v opačném pořadí.

Níže je uvedena implementace výše uvedeného přístupu:

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; }
Jáva 
/*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);  } }
Krajta 
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(prvek + ' ')); } // Příklad použití: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);

Výstup 
Reversed Array: 5 4 3 2 1
  • Časová náročnost: Na)
    • Kopírování prvků do nového pole je lineární operace.
  • Složitost pomocného prostoru: Na)
    • K uložení nového pole se používá další prostor.

2. Pole Reverzní Použití smyčky (na místě):

  • Iterujte pole pomocí dva ukazatele (začátek a konec).
  • Zaměňte prvky na počátečním a koncovém ukazateli.
  • Posuňte počáteční ukazatel ke konci a koncový ukazatel směrem k začátku, dokud se navzájem nepotkají nebo nepřekříží.

obrácené číslo

Níže je uvedena implementace výše uvedeného přístupu:

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; }
Jáva 
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);   }  }
Krajta 
# 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  ?>

Výstup 
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1
  • Časová náročnost: Na)
    • Smyčka prochází polovinou pole, takže je lineární s ohledem na velikost pole.
  • Složitost pomocného prostoru: O(1)
    • In-place obrácení, což znamená, že nezabere další prostor.

3. Reverzní vestavěné metody pole (nena místě):

  • Použijte vestavěné metody jako reverse> v Pythonu nebo Array.Reverse> v C#.

Níže je uvedena implementace výše uvedeného přístupu:

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; }
Jáva 
/*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));  } }
Krajta 
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);

Výstup 
5 4 3 2 1
  • Časová náročnost: Na reverse> metoda má typicky lineární časovou složitost.
  • Složitost pomocného prostoru: Na)
    • Další prostor se používá k uložení obráceného pole.

4. Pole Reverzní rekurze (na místě nebo bez umístění):

  • Definujte rekurzivní funkci, která přijímá pole jako vstup.
  • Prohoďte první a poslední prvek.
  • Rekurzivně zavolejte funkci se zbývajícím podpolí.

Níže je uvedena implementace výše uvedeného přístupu:

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) návrat;  int temp = arr[start];  arr[start] = arr[konec];  arr[konec] = teplota;  // Volání rekurzivní funkce reverseArray(arr, start + 1, end - 1); } /* Obslužná funkce pro tisk pole */ void printArray(int arr[], int velikost) { 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) návrat;  temp = arr[start];  arr[start] = arr[konec];  arr[konec] = teplota;  reverseArray(arr, začátek + 1, konec - 1); } /* Nástroj, který vytiskne pole na řádku */ void printArray(int arr[], int size) { int i;  pro (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; }
Jáva 
/*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) návrat;  temp = arr[start];  arr[start] = arr[konec];  arr[konec] = teplota;  reverseArray(arr, začátek + 1, konec - 1);  } /* Nástroj, který vytiskne pole na řádku */ 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*/
Krajta 
# Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= konec: return A[start], A[end] = A[end], A[start] reverseList(A, start+1, end-1) # Funkce ovladače k ​​otestování výše uvedené funkce A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Obrácený seznam je') print(A) # Tento program vytvořil 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) návrat;  temp = arr[start];  arr[start] = arr[konec];  arr[konec] = teplota;  reverseArray(arr, začátek + 1, konec - 1);  } /* Nástroj, který vytiskne pole na řádku */ 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>= $konec) { return; } $temp = $arr[$start]; $arr[$start] = $arr[$end]; $arr[$end] = $temp; // Rekurzivní volání funkce reverseArray($arr, $start + 1, $end - 1); } /* Obslužná funkce pro tisk pole */ funkce printArray(&$arr, $velikost) { 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); ?> 
    
  Výstup   
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
  
     
  •     Časová náročnost:     Na). Rekurze prochází každým prvkem jednou, takže je lineární.  
    •  
  •     Složitost pomocného prostoru:     O(n) pro non-in-place, O(log n) pro in-place (kvůli rekurznímu zásobníku).  
    •  
 
    5. Reverzní zásobník pole (není na místě):     
 
     
  •  Posuňte každý prvek pole do zásobníku.  
    •  
  •  Vyberte prvky ze zásobníku a vytvořte obrácené pole.  
    •  
 
 Níže je uvedena implementace výše uvedeného přístupu:  
C++   
#include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack zásobník;  // Vložení prvků do zásobníku pro (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('Přetečení zásobníku
');  vrátit se;  } stack->arr[++stack->top] = prvek; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  exit(1);  } return stack->arr[stack->top--]; } void reverseArrayUsingStack(int arr[], int velikost) { struct Stack stack;  stack.top = -1;  // Vložení prvků do zásobníku pro (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; } 
  Jáva   
/*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();  // Vložení prvků do zásobníku for (int element : arr) { stack.push(element);  } // Vybírá prvky ze zásobníku pro obrácení pole (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 + ' ');  }  } } 
  Krajta   
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 zásobník = nový zásobník ();  // Vložení prvků do zásobníku foreach(int element v arr) { stack.Push(element); } // Vybírá prvky ze zásobníku pro obrácení pole (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); 
    
  Výstup   
Reversed Array: 5 4 3 2 1 
  
     
  •     Časová náročnost:     Na)  
       
    •  Zatlačení a vysunutí každého prvku na/z zásobníku vyžaduje lineární čas.  
      •  
     
    •  
  •     Složitost pomocného prostoru:     Na)  
       
    •  Další prostor slouží k uložení stohu.  
      •  
     
    •  
 
 6.Dvoubodový přístup  
 
     
  •  Nastavte začátek na 0 a konec na velikost – 1.  
    •  
  •  Vyměňte prvky, dokud se ukazatele setkají: Když je začátek menší než konec, zaměňte arr[start] za arr[end].  
    •  
  •  Zaměňte arr[start] za arr[end].  
    •  
  •  Začátek zvýšení a konec snížení.  
    •  
  •  Pokračujte ve vyměňování a přesouvání ukazatelů, dokud nezačne křížek konec.  
    •  
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; } 
  Jáva   
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 
    
    Výstup:     
  
Reversed Array: 5 4 3 2 1 
 
    Časová náročnost:     O(n) – Tento algoritmus jednou iteruje polem, přičemž pro každý prvek provádí konstantní počet operací, což má za následek lineární časovou složitost.  
  
    Prostorová složitost:     O(1) – Algoritmus obrátí pole na místě bez použití dalších datových struktur, takže vyžaduje konstantní prostor bez ohledu na velikost vstupního pole.

Podíl

Mohlo By Se Vám Líbit

Fronta v Pythonu

Fronta v Pythonu

Najděte maximální hloubku nebo výšku daného binárního stromu

Najděte maximální hloubku nebo výšku daného binárního stromu

Nejlepší Články

Kategorie

Blog Java Konverze Matematika Kolekce Java Rozdíly Řetězec Java

Zajímavé Články