Sort given Array using at most N cyclic shift on any subarray
Last Updated :
21 Dec, 2021
Given an array arr[] containing N integers, with duplicates. The task is to sort the array in increasing order using at most N cyclic shift on any sub-array.
Cyclic shift on any sub-array means cut out any subarray from the given array, use cyclic shift (rotate) in it by any offset, and put it back into the same place of the array.
Print the number of such shifting required to sort the array. There can be multiple possibilities.
Examples:
Input: arr[] = [1, 3, 2, 8, 5]
Output: 2
Explanation: Consider segment from index = 1 to index = 2. [1, 3, 2, 8, 5]. Now rotate this segment by 1 offset. The new array becomes, [1, 2, 3, 8, 5].
Then consider segment from index = 3 to index = 4, [1, 2, 3, 8, 5]. Rotate it by 1 offset, the new array becomes, [1, 2, 3, 5, 8].
Input: arr[] = [2, 4, 1, 3]
Output: 2
Explanation: From index = 0 to index = 2, [2, 4, 1, 3]. Rotate this segment by 2 offset on left, the new array becomes, [1, 2, 4, 3].
Taking second segment from index = 2 to index = 3 of offset 1, rotate it the new array becomes, [1, 2, 4, 3].
Approach: There can be two cases:
- Case when the array is already sorted: Then we do not need to perform any shifting operation
- Case when the array is not sorted: For that follow the steps mentioned below:
- Create a variable count = 0 to store the total number of counts.
- Iterate from i = 0 to i = N-2. And for each iteration do the following operations:
- Create a variable minVal to store the minimum value found in this iteration and initiate it with the value of arr[i].
- Start iterating from i+1 to N-1. If the current value is less than minVal, update minVal.
- Mark that position right to perform cyclic shift from i to right by offset 1.
- If no such right value exists then simply move to the next iteration.
- Otherwise, rotate the array from i to right by 1 position and increment count by 1.
- Return the value of count as your answer.
Below is the C++ implementation for the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int ShiftingSort(vector< int >& arr, int n)
{
vector< int > temp(arr.begin(), arr.end());
sort(temp.begin(), temp.end());
int count = 0;
if (arr == temp) {
return 0;
}
else {
for ( int index1 = 0; index1 < n - 1; index1++) {
int minval = arr[index1];
int left = index1;
int right = -1;
for ( int index2 = index1 + 1; index2 < n;
index2++) {
if (minval > arr[index2]) {
minval = arr[index2];
right = index2;
}
}
if (right != -1) {
count++;
int index = right;
int tempval = arr[right];
while (index > left) {
arr[index] = arr[index - 1];
index--;
}
arr[index] = tempval;
}
}
}
return count;
}
int main()
{
vector< int > arr{ 1, 3, 2, 8, 5 };
int N = 5;
cout << ShiftingSort(arr, N) << "\n" ;
return 0;
}
|
Java
import java.util.*;
public class GFG
{
static int ShiftingSort(ArrayList<Integer> arr, int n)
{
ArrayList<Integer> temp = new ArrayList<Integer>();
for ( int i = 0 ; i < arr.size(); i++) {
temp.add(arr.get(i));
}
Collections.sort(temp);
int count = 0 ;
if (arr.equals(temp)) {
return 0 ;
}
else {
for ( int index1 = 0 ; index1 < n - 1 ; index1++) {
int minval = arr.get(index1);
int left = index1;
int right = - 1 ;
for ( int index2 = index1 + 1 ; index2 < n;
index2++) {
if (minval > arr.get(index2)) {
minval = arr.get(index2);
right = index2;
}
}
if (right != - 1 ) {
count++;
int index = right;
int tempval = arr.get(right);
while (index > left) {
arr.set(index, arr.get(index - 1 ));
index--;
}
arr.set(index, tempval);
}
}
}
return count;
}
public static void main(String args[])
{
ArrayList<Integer> arr = new ArrayList<Integer>();
arr.add( 1 );
arr.add( 3 );
arr.add( 2 );
arr.add( 8 );
arr.add( 5 );
int N = 5 ;
System.out.println(ShiftingSort(arr, N));
}
}
|
Python3
def ShiftingSort(arr, n):
temp = arr.copy()
temp.sort()
count = 0
if (arr = = temp):
return 0
else :
for index1 in range (n - 1 ):
minval = arr[index1]
left = index1
right = - 1
for index2 in range (index1 + 1 , n):
if (minval > arr[index2]):
minval = arr[index2]
right = index2
if (right ! = - 1 ):
count + = 1
index = right
tempval = arr[right]
while (index > left):
arr[index] = arr[index - 1 ]
index - = 1
arr[index] = tempval
return count
arr = [ 1 , 3 , 2 , 8 , 5 ]
N = 5
print (ShiftingSort(arr, N))
|
C#
using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{
static int ShiftingSort(ArrayList arr, int n)
{
ArrayList temp = new ArrayList();
for ( int i = 0; i < arr.Count; i++) {
temp.Add(arr[i]);
}
temp.Sort();
int count = 0;
if (arr.Equals(temp)) {
return 0;
}
else
{
for ( int index1 = 0; index1 < n - 1; index1++) {
int minval = ( int )arr[index1];
int left = index1;
int right = -1;
for ( int index2 = index1 + 1; index2 < n;
index2++) {
if (minval > ( int )arr[index2]) {
minval = ( int )arr[index2];
right = index2;
}
}
if (right != -1)
{
count++;
int index = right;
int tempval = ( int )arr[right];
while (index > left) {
arr[index] = arr[index - 1];
index--;
}
arr[index] = tempval;
}
}
}
return count;
}
public static void Main()
{
ArrayList arr = new ArrayList();
arr.Add(1);
arr.Add(3);
arr.Add(2);
arr.Add(8);
arr.Add(5);
int N = 5;
Console.Write(ShiftingSort(arr, N));
}
}
|
Javascript
<script>
function ShiftingSort(arr, n) {
let temp = [...arr];
temp.sort( function (a, b) { return a - b })
let count = 0;
if (arr == temp) {
return 0;
}
else {
for (let index1 = 0; index1 < n - 1; index1++) {
let minval = arr[index1];
let left = index1;
let right = -1;
for (let index2 = index1 + 1; index2 < n;
index2++) {
if (minval > arr[index2]) {
minval = arr[index2];
right = index2;
}
}
if (right != -1)
{
count++;
let index = right;
let tempval = arr[right];
while (index > left) {
arr[index] = arr[index - 1];
index--;
}
arr[index] = tempval;
}
}
}
return count;
}
let arr = [1, 3, 2, 8, 5];
let N = 5;
document.write(ShiftingSort(arr, N) + '<br>' );
</script>
|
Time Complexity: O(N2)
Space Complexity: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...