MASĪVA REVERSS VALODĀ C/C++/JAVA/PYTHON/JAVASCRIPT

Masīva reverss vai apgriezt masīvu nozīmē mainīt katra dotā masīva skaitļa pozīciju uz pretējo pozīciju no beigām, t.i., ja skaitlis atrodas 1. pozīcijā, tad tā jaunā pozīcija būs Array.length, līdzīgi, ja skaitlis atrodas 2. pozīcijā, tad tā jaunā pozīcija būs Masīvs.garums – 1 un tā tālāk.

Masīvs apgriezts C/C++/Java/Python/JavaScript

Ņemot vērā masīvu (vai virkni), uzdevums ir apgriezt masīvu/virkni.

Piemēri:

Ievade: sākotnējais_masīvs[] = {1, 2, 3} Izvade: masīvs_apgriezts[] = {3, 2, 1}

Ievade: sākotnējais_masīvs[] = {4, 5, 1, 2}
Izvade: masīvs_apgriezts[] = {2, 1, 5, 4}

Satura rādītājs

1. Masīvs apgriezts, izmantojot papildu masīvu (nav uz vietas):
2. Masīvs apgriezts, izmantojot cilpu (uz vietas):
3. Masīva reversās iebūvētās metodes (nav uz vietas):
4. Masīva apgrieztā rekursija (uz vietas vai nevietā):
5. Masīva apgrieztā kaudze (nav uz vietas):

1. Masīvs Reverse Papildu masīva izmantošana (nav uz vietas):

Izveidojiet jaunu masīvu, kas ir tāda paša izmēra kā sākotnējais masīvs.
Kopējiet elementus no sākotnējā masīva uz jauno masīvu apgrieztā secībā.

Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.

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 + ' ')); } // Lietošanas piemērs: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);>>   
  Izvade   Reversed Array: 5 4 3 2 1 
         Laika sarežģītība:     O(n)    Elementu kopēšana jaunā masīvā ir lineāra darbība.  
 
 
     Papildtelpu sarežģītība:     O(n)    Jaunā masīva glabāšanai tiek izmantota papildu vieta.  
 
 
 
  2. Masīvs Reverss     Izmantojot cilpu (uz vietas):     
   Atkārtojiet masīvu, izmantojot   divas norādes   (sākums un beigas).  
  Mainiet elementus sākuma un beigu rādītājos.  
  Pārvietojiet sākuma rādītāju uz beigām un beigu rādītāju uz sākumu, līdz tie saskaras vai šķērso viens otru.  
 
   
   Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.  
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  ?>>>   
  Izvade       Laika sarežģītība:     O(n)    Cilpa iet cauri pusei no masīva, tāpēc tā ir lineāra attiecībā pret masīva lielumu.  
 
      Papildtelpu sarežģītība:     O(1)    Vietējā apgriešana, kas nozīmē, ka tā neizmanto papildu vietu.  
 
 
      3. Masīva reversās iebūvētās metodes (nav uz vietas):     
   Izmantojiet iebūvētās metodes, piemēram  reverse>  Python vai  Array.Reverse>  valodā C #.  
 
  Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.  
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); 
    
  Izvade       Laika sarežģītība:     Uz  reverse>  metodei parasti ir lineāra laika sarežģītība.       Papildtelpu sarežģītība:     O(n)    Apgrieztā masīva glabāšanai tiek izmantota papildu vieta.  
 
 
      4. Masīva apgrieztā rekursija (uz vietas vai nevietā):     
   Definējiet rekursīvu funkciju, kas izmanto masīvu kā ievadi.  
  Apmainiet pirmo un pēdējo elementu.  
  Rekursīvi izsauciet funkciju ar atlikušo apakšgrupu.  
 
  Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.  
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>= beigas) atgriešanās;  int temp = arr[sākt];  arr[sākums] = arr[beigas];  arr[beigas] = temp;  // Rekursīvā funkcija, kas izsauc reverseArray(arr, sākums + 1, beigas - 1); } /* Utilīta funkcija masīva drukāšanai */ void printArray(int arr[], int izmērs) { 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>= beigas) atgriešanās;  temp = arr [sākt];  arr[sākums] = arr[beigas];  arr[beigas] = temp;  reverseArray(arr, sākums + 1, beigas - 1); } /* Utilīta, kas izdrukā masīvu uz līnijas */ void printArray(int arr[], int size) { int i;  par (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>= beigas) atgriešanās;  temp = arr [sākt];  arr[sākums] = arr[beigas];  arr[beigas] = temp;  reverseArray(arr, sākums + 1, beigas - 1);  } /* Utilīta, kas izdrukā masīvu rindā */ 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>= beigas: atgriešanās A[sākums], A[beigas] = A[beigas], A[sākums] reverseList(A, sākums+1, beigas-1) # Pārbaudāmā draivera funkcija A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Apgrieztais saraksts ir') print(A) # Šīs programmas autors ir 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>= beigas) atgriešanās;  temp = arr [sākt];  arr[sākums] = arr[beigas];  arr[beigas] = temp;  reverseArray(arr, sākums + 1, beigas - 1);  } /* Utilīta, kas izdrukā masīvu uz līnijas */ static void printArray(int[] arr, int izmērs) { 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>= $beigas) { return; } $temp = $arr[$sākt]; $arr[$sākums] = $arr[$beigas]; $arr[$end] = $temp; // Rekursīvās funkcijas izsaukšana reverseArray($arr, $start + 1, $end - 1); } /* Lietderības funkcija masīva drukāšanai */ 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); ?>>>   
  Izvade   1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
         Laika sarežģītība:     O(n). Rekursija iet cauri katram elementam vienu reizi, tāpēc tā ir lineāra.  
     Papildtelpu sarežģītība:     O(n) nevietā, O(log n) vietā (rekursijas steka dēļ).  
 
     5. Masīva apgrieztā kaudze (nav uz vietas):     
   Nospiediet katru masīva elementu uz kaudzītes.  
  Izvelciet elementus no steka, lai izveidotu apgrieztu masīvu.  
 
  Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.  
C++   #include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack kaudze;  // Nospiediet elementus uz kaudzītes, lai iegūtu (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('Steck Overflow
');  atgriešanās;  } kaudze->arr[++steka->augšā] = elements; } int pop(struct Stack* kaudze) { if (steck->top == -1) { printf('Stack Underflow
');  izeja(1);  } return steck->arr[steck->top--]; } void reverseArrayUsingStack(int arr[], int izmērs) { struct Stack kaudze;  kaudze.top = -1;  // Spiediet elementus uz kaudzītes (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 kaudze = new Stack();  // Nospiediet elementus stekā for (int elements : arr) { stack.push(element);  } // Izbīdīt elementus no steka, lai mainītu masīvu priekš (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 kaudze = jauns kaudze ();  // Nospiediet elementus uz steku foreach(int elements in arr) { kaudze.Push(element); } // Izbīdīt elementus no steka, lai mainītu masīvu priekš (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); 
    
  Izvade       Laika sarežģītība:     O(n)    Katra elementa nospiešana un izlikšana uz kaudzītes/no tās prasa lineāru laiku.  
 
      Papildtelpu sarežģītība:     O(n)    Papildu vieta tiek izmantota kaudzes glabāšanai.  
 
 
   6. Divu rādītāju pieeja  
   Iestatiet sākumu uz 0 un beigas uz izmēru – 1.  
  Apmainiet elementus, līdz satiekas norādes: kamēr sākums ir mazāks par beigas, samainiet arr[sākt] ar arr[end].  
  Apmaini arr[sākt] ar arr[end].  
  Palielināt sākumu un samazināšanas beigas.  
  Turpiniet apmainīt un pārvietot rādītājus, līdz beidzas sākuma krusti.  
 
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 
        Izvade:     
  Reversed Array: 5 4 3 2 1 
     Laika sarežģītība:     O(n) — šis algoritms atkārtojas masīvā vienu reizi, katram elementam veicot nemainīgu darbību skaitu, kā rezultātā rodas lineāra laika sarežģītība.  
      Kosmosa sarežģītība:     O(1) – algoritms apvērš masīvu vietā, neizmantojot nekādas papildu datu struktūras, tādējādi neatkarīgi no ievades masīva lieluma ir nepieciešama pastāvīga vieta.