In-Place Algorithm

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// An in-place C# program
// to reverse an array
using System; 
      
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++)
            Console.Write(arr[i] + " "); 
        Console.WriteLine("");
    
      
    // 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); 
        Console.WriteLine("Reversed array is");
        printArray(arr, n); 
    }
}
  
/* This code is contributed by PrinciRaj1992 */

chevron_right


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 arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.