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.
Share your thoughts in the comments
Please Login to comment...