C/C++/JAVA/PYTHON/JAVASCRIPT의 배열 역방향

배열 역방향 또는 배열을 뒤집다 주어진 배열의 각 숫자 위치를 끝에서 반대 위치로 변경하는 것을 의미합니다. 즉, 숫자가 위치 1에 있으면 새 위치는 Array.length가 되고, 마찬가지로 숫자가 위치 2에 있으면 새 위치는 다음과 같습니다. Array.length – 1 등.

C/C++/Java/Python/JavaScript의 배열 역방향

배열(또는 문자열)이 주어지면 작업은 배열/문자열을 뒤집는 것입니다.

예:

입력: 원본_배열[] = {1, 2, 3} 산출: array_reversed[] = {3, 2, 1}

입력: 원본_배열[] = {4, 5, 1, 2}
산출: array_reversed[] = {2, 1, 5, 4}

내용의 테이블

1. 추가 어레이(비-제자리)를 사용한 어레이 역방향:
2. 루프를 사용한 배열 역방향(내부):
3. 배열 역방향 내장 방법(비 내부):
4. 배열 역방향 재귀(in-place 또는 non-in-place):
5. 어레이 역방향 스택(비 제자리):

1. 배열 역방향 추가 배열 사용(비-제자리):

원래 배열과 동일한 크기의 새 배열을 만듭니다.
원래 배열의 요소를 새 배열에 역순으로 복사합니다.

다음은 위의 접근 방식을 구현한 것입니다.

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

자바

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

파이썬

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

자바스크립트

  function reverseArrayExtraArray(arr) {  const reversedArr = arr.slice().reverse();  // Print reversed array  process.stdout.write('Reversed Array: ');  reversedArr.forEach(element =>process.stdout.write(요소 + ' ')); } // 사용 예: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);

산출

Reversed Array: 5 4 3 2 1

시간 복잡도: 에)
- 새 배열에 요소를 복사하는 것은 선형 작업입니다.
보조 공간 복잡성: 에)
- 새 어레이를 저장하는 데 추가 공간이 사용됩니다.

2. 배열 역방향 루프 사용(내부):

다음을 사용하여 배열을 반복합니다. 두 개의 포인터 (시작과 끝).
시작 및 끝 포인터에서 요소를 바꿉니다.
서로 만나거나 교차할 때까지 시작 포인터를 끝쪽으로 이동하고 종료 포인터를 시작쪽으로 이동합니다.

숫자 뒤집기

다음은 위의 접근 방식을 구현한 것입니다.

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

자바

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

파이썬

  # 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

자바스크립트

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

산출

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

시간 복잡도: 에)
- 루프는 배열의 절반을 통과하므로 배열 크기에 대해 선형입니다.
보조 공간 복잡성: 오(1)
- 내부 반전은 추가 공간을 사용하지 않음을 의미합니다.

3. 배열 역방향 내장 방법(비 내부):

다음과 같은 내장 메소드를 사용하세요. reverse> 파이썬에서 또는 Array.Reverse> C#에서.

다음은 위의 접근 방식을 구현한 것입니다.

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

자바

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

파이썬

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

자바스크립트

  let originalArray = [1, 2, 3, 4, 5]; // Using inbuilt method in JavaScript let reversedArray = originalArray.slice().reverse(); // Print the reversed array console.log(reversedArray);

산출

5 4 3 2 1

시간 복잡도: O(n) reverse> 방법은 일반적으로 선형적인 시간 복잡도를 갖습니다.
보조 공간 복잡성: 에)
- 역방향 배열을 저장하는 데 추가 공간이 사용됩니다.

4. 배열 역방향 재귀(in-place 또는 non-in-place):

배열을 입력으로 사용하는 재귀 함수를 정의합니다.
첫 번째 요소와 마지막 요소를 바꿉니다.
나머지 하위 배열을 사용하여 함수를 재귀적으로 호출합니다.

다음은 위의 접근 방식을 구현한 것입니다.

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>= 끝) 반환;  int temp = arr[시작];  도착[시작] = 도착[끝];  도착[끝] = 온도;  // reverseArray(arr, start + 1, end - 1)를 호출하는 재귀 함수; } /* 배열을 인쇄하는 유틸리티 함수 */ 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>= 끝) 반환;  온도 = arr[시작];  도착[시작] = 도착[끝];  도착[끝] = 온도;  reverseArray(arr, 시작 + 1, 끝 - 1); } /* 한 줄에 배열을 인쇄하는 유틸리티 */ void printArray(int arr[], int size) { int i;  (i = 0; 나는 < 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; }

자바

  /*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>= 끝) 반환;  온도 = arr[시작];  도착[시작] = 도착[끝];  도착[끝] = 온도;  reverseArray(arr, 시작 + 1, 끝 - 1);  } /* 한 줄에 배열을 인쇄하는 유틸리티 */ 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*/

파이썬

  # Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= end: return A[start], A[end] = A[end], A[start] reverseList(A, start+1, end-1) # 위 테스트를 위한 드라이버 함수 function A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('역방향 목록은') print(A) # 이 프로그램은 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>= 끝) 반환;  온도 = arr[시작];  도착[시작] = 도착[끝];  도착[끝] = 온도;  reverseArray(arr, 시작 + 1, 끝 - 1);  } /* 한 줄에 배열을 인쇄하는 유틸리티 */ 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

자바스크립트

// 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) { 반환; } $temp = $arr[$start]; $arr[$start] = $arr[$end]; $arr[$end] = $temp; // reverseArray($arr, $start + 1, $end - 1)를 호출하는 재귀 함수; } /* 배열을 인쇄하는 유틸리티 함수 */ 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); ?> 
    
  산출   1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
       시간 복잡도:     에). 재귀는 각 요소를 한 번씩 거치므로 선형입니다.  
     보조 공간 복잡성:     제자리에 있지 않은 경우 O(n), 제자리에 있으면 O(log n)(재귀 스택으로 인해).  
 
     5. 어레이 역방향 스택(비 제자리):     
   배열의 각 요소를 스택에 푸시합니다.  
  스택에서 요소를 팝하여 역방향 배열을 형성합니다.  
 
  다음은 위의 접근 방식을 구현한 것입니다.  
C++   #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack 스택;  // 요소를 스택에 푸시합니다 for (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; } 
  씨   #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('스택 오버플로
');  반품;  } 스택->arr[++stack->top] = 요소; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  출구(1);  } return 스택->arr[스택->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack 스택;  stack.top = -1;  // 요소를 스택에 푸시합니다 for (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; } 
  자바   /*package whatever //do not write package name here */ import java.util.Stack; public class ReverseArrayUsingStack {  public static void reverseArrayUsingStack(int[] arr)  {  Stack 스택 = 새로운 스택();  // 스택에 요소를 푸시합니다. for (int element : arr) { stack.push(element);  } // 스택에서 요소를 꺼내어 배열을 뒤집습니다. for (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 + ' ');  }  } } 
  파이썬   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) 
  씨#   using System; using System.Collections.Generic; class Program {  static void ReverseArrayUsingStack(int[] arr)  {  Stack 스택 = 새 스택 ();  // 스택에 요소를 푸시합니다. foreach(int element in arr) { stack.Push(element); } // 스택에서 요소를 꺼내어 배열을 뒤집습니다. for (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 + ' ');  }  } } 
  자바스크립트   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); 
    
  산출   Reversed Array: 5 4 3 2 1 
       시간 복잡도:     에)    스택에 각 요소를 푸시하고 팝하는 데는 선형 시간이 필요합니다.  
 
 
     보조 공간 복잡성:     에)    스택을 저장하는 데 추가 공간이 사용됩니다.  
 
 
 
  6. 두 포인터 접근 방식  
   시작을 0으로 설정하고 끝을 크기 – 1로 설정합니다.  
  포인터가 만날 때까지 요소 교환: 시작이 끝보다 작은 동안 arr[start]를 arr[end]로 교환합니다.  
  arr[start]를 arr[end]로 바꿉니다.  
  증가 시작 및 감소 끝.  
  시작이 끝을 지나갈 때까지 포인터를 계속 교체하고 이동합니다.  
 
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; } 
  자바   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 
        산출:     
  Reversed Array: 5 4 3 2 1 
     시간 복잡도:     O(n) – 이 알고리즘은 배열을 한 번 반복하여 각 요소에 대해 일정한 수의 작업을 수행하므로 선형 시간 복잡도가 발생합니다.  
      공간 복잡도:     O(1) – 알고리즘은 추가 데이터 구조를 사용하지 않고 배열을 제자리에서 반전시키므로 입력 배열의 크기에 관계없이 일정한 공간이 필요합니다.