In-Place Algorithm - GeeksforGeeks

In-place has more than one definitions. One strict definition is.

An in-place algorithm is an algorithm that does not need an extra space and produces an output in the same memory that contains the data by transforming the input ‘in-place’. However, a small constant extra space used for variables is allowed.

A more broad definition is,

In-place means that the algorithm does not use extra space for manipulating the input but may require a small though nonconstant extra space for its operation. Usually, this space is O(log n), though sometimes anything in o(n) (Smaller than linear) is allowed [Source : Wikipedia]

A Not In-Place Implementation of reversing an array

C++

// An Not in-place C++ program to reverse an array 
#include <bits/stdc++.h> 
using namespace std; 
   
/* Function to reverse arr[] from start to end*/
void revereseArray(int arr[], int n) 
{ 
   // Create a copy array and store reversed 
   // elements 
   int rev[n]; 
   for (int i=0; i<n; i++) 
       rev[n-i-1] = arr[i]; 
   
   // Now copy reversed elements back to arr[] 
   for (int i=0; i<n; i++) 
       arr[i] = rev[i]; 
}      
   
/* 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]); 
    printArray(arr, n);      
    revereseArray(arr, n);      
    cout << "Reversed array is" << endl; 
    printArray(arr, n);      
    return 0; 
} 

Java

// An Not in-place Java program 
// to reverse an array 
import java.util.*; 
  
class GFG 
{ 
    /* Function to reverse arr[] 
       from start to end*/
    public static void revereseArray(int []arr,  
                                     int n) 
    { 
        // Create a copy array 
        // and store reversed 
        // elements 
        int []rev = new int[n]; 
        for (int i = 0; i < n; i++) 
            rev[n - i - 1] = arr[i]; 
          
        // Now copy reversed  
        // elements back to arr[] 
        for (int i = 0; i < n; i++) 
            arr[i] = rev[i]; 
    }  
      
    /* Utility function to 
       print an array */
    public 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};  
        int n = arr.length; 
        printArray(arr, n);  
        revereseArray(arr, n);  
        System.out.println("Reversed array is"); 
        printArray(arr, n);  
    } 
} 
  
// This code is contributed 
// by Harshit Saini 

Python3

# An Not in-place Python program  
# to reverse an array 
  
''' Function to reverse arr[] 
    from start to end '''
def revereseArray(arr, n): 
      
    # Create a copy array  
    # and store reversed 
    # elements 
    rev = n * [0] 
    for i in range(0, n): 
        rev[n - i - 1] = arr[i] 
              
    # Now copy reversed 
    # elements back to arr[] 
    for i in range(0, n): 
        arr[i] = rev[i] 
          
# Driver code 
if __name__ == "__main__": 
    arr = [1, 2, 3, 4, 5, 6] 
    n = len(arr) 
    print(*arr)  
    revereseArray(arr, n);  
    print("Reversed array is") 
    print(*arr)  
      
# This code is contributed 
# by Harshit Saini 

C#

// An Not in-place C# program 
// to reverse an array 
using System; 
  
class GFG 
{ 
    /* Function to reverse arr[] 
    from start to end*/
    public static void revereseArray(int[] arr,  
                                    int n) 
    { 
        // Create a copy array 
        // and store reversed 
        // elements 
        int[] rev = new int[n]; 
        for (int i = 0; i < n; i++) 
            rev[n - i - 1] = arr[i]; 
          
        // Now copy reversed  
        // elements back to arr[] 
        for (int i = 0; i < n; i++) 
            arr[i] = rev[i]; 
    }  
      
    /* Utility function to 
    print an array */
    public static void printArray(int[] arr,  
                                int size) 
    { 
    for (int i = 0; i < size; i++) 
        Console.Write(arr[i] + " "); 
    Console.Write("\n"); 
    }  
      
    // Driver code 
    public static void Main()  
    { 
        int[] arr = {1, 2, 3, 4, 5, 6};  
        int n = arr.Length; 
        printArray(arr, n);  
        revereseArray(arr, n);  
        Console.WriteLine("Reversed array is"); 
        printArray(arr, n);  
    } 
} 
  
// This code is contributed by Ita_c. 

Output:

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

This needs O(n) extra space and is an example of not-in-place algorithm.

An In-Place Implementation of Reversing an array.

C++

// An in-place C++ program to reverse an array 
#include <bits/stdc++.h> 
using namespace std; 
   
/* Function to reverse arr[] from start to end*/
void revereseArray(int arr[], int n) 
{ 
   for (int i=0; i<n/2; i++) 
     swap(arr[i], arr[n-i-1]); 
}      
   
/* 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]);  
    printArray(arr, n);      
    revereseArray(arr, n);      
    cout << "Reversed array is" << endl; 
    printArray(arr, n);      
    return 0; 
} 

Java

// An in-place Java program 
// to reverse an array 
import java.util.*; 
  
class GFG 
{ 
    public static int __(int x, int y) {return x;} 
      
    /* Function to reverse arr[]  
       from start to end*/
    public static void revereseArray(int []arr,  
                                     int n) 
    { 
        for (int i = 0; i < n / 2; i++) 
            arr[i] = __(arr[n - i - 1],  
                        arr[n - i - 1] = arr[i]); 
    }  
      
    /* Utility function to  
       print an array */
    public static void printArray(int []arr,  
                                  int size) 
    { 
        for (int i = 0; i < size; i++) 
            System.out.print(Integer.toString(arr[i]) + " ");  
        System.out.println(""); 
    }  
      
    // Driver code 
    public static void main(String[] args)  
    { 
        int []arr = new int[]{1, 2, 3, 4, 5, 6};  
        int n = arr.length; 
        printArray(arr, n);  
        revereseArray(arr, n);  
        System.out.println("Reversed array is"); 
        printArray(arr, n);  
    } 
} 
  
// This code is contributed  
// by Harshit Saini 

Python3

# An in-place Python program 
# to reverse an array 
  
''' Function to reverse arr[] 
    from start to end'''
def revereseArray(arr, n): 
      
    for i in range(0, int(n / 2)): 
        arr[i], arr[n - i - 1] = arr[n - i - 1], arr[i] 
  
  
# Driver code 
if __name__ == "__main__": 
      
    arr = [1, 2, 3, 4, 5, 6] 
    n = len(arr) 
    print(*arr) 
    revereseArray(arr, n)  
    print("Reversed array is") 
    print(*arr) 
      
# This code is contributed  
# by Harshit Saini 

Output:

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

This needs O(1) extra space for exchanging elements and is an example of in-place algorithm.

Which Sorting Algorithms are In-Place and which are not?
In Place : Bubble sort, Selection Sort, Insertion Sort, Heapsort.

Not In-Place : Merge Sort. Note that merge sort requires O(n) extra space.

What about QuickSort? Why is it called In-Place?
QuickSort uses extra space for recursive function calls. It is called in-place according to broad definition as extra space required is not used to manipulate input, but only for recursive calls.

My Personal Notes

Suggest a Topic

C++

Java

Python3

C#

C++

Java

Python3

Recommended Posts: