In-Place Algorithm
Last Updated :
29 Aug, 2022
In-place has more than one definition. 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 non-constant extra space for its operation. Usually, this space is O(log n), though sometimes anything in O(n) (Smaller than linear) is allowed.
A Not In-Place Implementation of reversing an array
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void reverseArray( int arr[], int n)
{
int rev[n];
for ( int i=0; i<n; i++)
rev[n-i-1] = arr[i];
for ( int i=0; i<n; i++)
arr[i] = rev[i];
}
void printArray( int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6};
int n = sizeof (arr)/ sizeof (arr[0]);
printArray(arr, n);
reverseArray(arr, n);
cout << "Reversed array is" << endl;
printArray(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
public static void reverseArray( int []arr,
int n)
{
int []rev = new int [n];
for ( int i = 0 ; i < n; i++)
rev[n - i - 1 ] = arr[i];
for ( int i = 0 ; i < n; i++)
arr[i] = rev[i];
}
public static void printArray( int []arr,
int size)
{
for ( int i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println( "" );
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 };
int n = arr.length;
printArray(arr, n);
reverseArray(arr, n);
System.out.println( "Reversed array is" );
printArray(arr, n);
}
}
|
Python3
def reverseArray(arr, n):
rev = n * [ 0 ]
for i in range ( 0 , n):
rev[n - i - 1 ] = arr[i]
for i in range ( 0 , n):
arr[i] = rev[i]
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 ]
n = len (arr)
print ( * arr)
reverseArray(arr, n);
print ( "Reversed array is" )
print ( * arr)
|
C#
using System;
class GFG
{
public static void reverseArray( int [] arr,
int n)
{
int [] rev = new int [n];
for ( int i = 0; i < n; i++)
rev[n - i - 1] = arr[i];
for ( int i = 0; i < n; i++)
arr[i] = rev[i];
}
public static void printArray( int [] arr,
int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.Write( "\n" );
}
public static void Main()
{
int [] arr = {1, 2, 3, 4, 5, 6};
int n = arr.Length;
printArray(arr, n);
reverseArray(arr, n);
Console.WriteLine( "Reversed array is" );
printArray(arr, n);
}
}
|
Javascript
<script>
function reverseArray(arr,n)
{
let rev = new Array(n);
for (let i = 0; i < n; i++)
rev[n - i - 1] = arr[i];
for (let i = 0; i < n; i++)
arr[i] = rev[i];
}
function printArray(arr,size)
{
for (let i = 0; i < size; i++)
document.write(arr[i] + " " );
document.write( "<br>" );
}
let arr=[1, 2, 3, 4, 5, 6];
let n = arr.length;
printArray(arr, n);
reverseArray(arr, n);
document.write( "Reversed array is<br>" );
printArray(arr, n);
</script>
|
Output
1 2 3 4 5 6
Reversed array is
6 5 4 3 2 1
Time Complexity: O(n)
This needs O(n) extra space and is an example of a not-in-place algorithm.
An In-Place Implementation of Reversing an array.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void reverseArray( int arr[], int n)
{
for ( int i=0; i<n/2; i++)
swap(arr[i], arr[n-i-1]);
}
void printArray( int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6};
int n = sizeof (arr)/ sizeof (arr[0]);
printArray(arr, n);
reverseArray(arr, n);
cout << "Reversed array is" << endl;
printArray(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
public static int __( int x, int y) { return x;}
public static void reverseArray( int []arr,
int n)
{
for ( int i = 0 ; i < n / 2 ; i++)
arr[i] = __(arr[n - i - 1 ],
arr[n - i - 1 ] = arr[i]);
}
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( "" );
}
public static void main(String[] args)
{
int []arr = new int []{ 1 , 2 , 3 , 4 , 5 , 6 };
int n = arr.length;
printArray(arr, n);
reverseArray(arr, n);
System.out.println( "Reversed array is" );
printArray(arr, n);
}
}
|
Python3
def reverseArray(arr, n):
for i in range ( 0 , int (n / 2 )):
arr[i], arr[n - i - 1 ] = arr[n - i - 1 ], arr[i]
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 ]
n = len (arr)
print ( * arr)
reverseArray(arr, n)
print ( "Reversed array is" )
print ( * arr)
|
C#
using System;
class GFG
{
public static int __( int x, int y) { return x;}
public static void reverseArray( int []arr,
int n)
{
for ( int i = 0; i < n / 2; i++)
arr[i] = __(arr[n - i - 1],
arr[n - i - 1] = arr[i]);
}
public static void printArray( int []arr,
int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine( "" );
}
public static void Main(String[] args)
{
int []arr = new int []{1, 2, 3, 4, 5, 6};
int n = arr.Length;
printArray(arr, n);
reverseArray(arr, n);
Console.WriteLine( "Reversed array is" );
printArray(arr, n);
}
}
|
Javascript
<script>
function __(x,y)
{
return x;
}
function reverseArray(arr,n)
{
for (let i = 0; i < n / 2; i++)
arr[i] = __(arr[n - i - 1],
arr[n - i - 1] = arr[i]);
}
function printArray(arr,size)
{
for (let i = 0; i < size; i++)
document.write(arr[i] + " " );
document.write( "<br>" );
}
let arr=[1, 2, 3, 4, 5, 6];
let n = arr.length;
printArray(arr, n);
reverseArray(arr, n);
document.write( "Reversed array is<br>" );
printArray(arr, n);
</script>
|
Output
1 2 3 4 5 6
Reversed array is
6 5 4 3 2 1
Time Complexity: O(n)
This needs O(1) extra space for exchanging elements and is an example of an 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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...