Skip to content
Related Articles

Related Articles

Sort Array such that smallest is at 0th index and next smallest it at last index and so on

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 18 Jan, 2022

Given an array, arr[] of N integers, the task is to rearrange the array elements such that the smallest element is at the 0th position, the second smallest element is at the (N-1)th position, the third smallest element at 1st position, 4th smallest element is at the (N-2)th position, and so on for all integers in arr[].

Examples:

Input: arr[] = {10, 23, 12, 17, 9}
Output: 9 12 23 17 10
Explanation:
The smallest element is 9 which is put in the index 0. 
Then the second smallest element is 10 which is put in the last position.
The third smallest element is put in the second position from the start.
The fourth smallest in the second position from the last and so on.
Input: arr[] = {1, 3, 3, 4, 5}
Output: 1 3 5 4 3

Approach: We will be using the Two Pointer Technique. The idea is to iterate from the start marked by variable i to the end marked by variable j of the array alternatively until they meet in the middle and keep updating the minimum values at these indices. Below are the steps:

  1. Set the element at index i as the minimum value. Iterate over [i, j] and compare each value in this range with arr[i], and if the value in the range is less than arr[i] then swap the value between arr[i] and the current element. Increment the value of i.
  2. Set the element at index j as the minimum value. Iterate over [i, j] and compare each value in this range with arr[j], and if the value in the range is less than arr[j] then swap the value between arr[j] and the current element. Decrement the value of j.
  3. Place the smallest element in the ith position at the first iteration and the next smallest element in the jth position. Do this until both i and j point to the same position.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to perform the rearrangement
void rearrange(int a[], int N)
{
     
    // Initialize variables
    int i = 0, j = N - 1;
    int min = 0, k, x = 0, temp;
 
    // Loop until i crosses j
    while (i < j)
    {
 
        // This check is to find the
        // minimum values in the
        // ascending order
        for(k = i; k <= j; k++)
        {
            if (a[k] < a[min])
                min = k;
        }
 
        // Condition to alternatively
        // iterate variable i and j
        if (x % 2 == 0)
        {
 
            // Perform swap operation
            temp = a[i];
            a[i] = a[min];
            a[min] = temp;
 
            // Increment i
            i++;
 
            // Assign the value of min
            min = i;
        }
        else
        {
 
            // Perform swap
            temp = a[j];
            a[j] = a[min];
            a[min] = temp;
 
            // Decrement i
            j--;
 
            // Assign the value of min
            min = j;
        }
        x++;
    }
 
    // Print the array
    for(i = 0; i < N; i++)
        cout << a[i] << " ";
}
 
// Driver Code
int main()
{
     
    // Given Array arr[]
    int arr[] = { 1, 3, 3, 4, 5 };
     
    int N = sizeof(arr) / sizeof(arr[0]);
     
    // Function call
    rearrange(arr, N);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java



// Java program for the above approach
import java.io.*;
import java.util.*;
 
public class GFG {
 
    // Function to perform the rearrangement
    static void rearrange(int[] a)
    {
        // Initialize variables
        int i = 0, j = a.length - 1;
        int min = 0, k, x = 0, temp;
 
        // Loop until i crosses j
        while (i < j) {
 
            // This check is to find the
            // minimum values in the
            // ascending order
 
            for (k = i; k <= j; k++) {
                if (a[k] < a[min])
                    min = k;
            }
 
            // Condition to alternatively
            // iterate variable i and j
            if (x % 2 == 0) {
 
                // Perform swap operation
                temp = a[i];
                a[i] = a[min];
                a[min] = temp;
 
                // Increment i
                i++;
 
                // Assign the value of min
                min = i;
            }
            else {
 
                // Perform swap
                temp = a[j];
                a[j] = a[min];
                a[min] = temp;
 
                // Decrement i
                j--;
 
                // Assign the value of min
                min = j;
            }
            x++;
        }
 
        // Print the array
        for (i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given Array arr[]
        int arr[] = { 1, 3, 3, 4, 5 };
 
        // Function Call
        rearrange(arr);
    }
}
Python3



# Python3 program for
# the above approach
# Function to perform
# the rearrangement
def rearrange(a, N):
 
    # Initialize variables
    i = 0
    j = N - 1
    min = 0
    x = 0
 
    # Loop until i crosses j
    while (i < j):
     
        # This check is to find the
        # minimum values in the
        # ascending order
        for k in range (i, j + 1):
            if (a[k] < a[min]):
                min = k
 
        # Condition to alternatively
        # iterate variable i and j
        if (x % 2 == 0):
         
            # Perform swap operation
            temp = a[i]
            a[i] = a[min]
            a[min] = temp
 
            # Increment i
            i += 1
 
            # Assign the value of min
            min = i
         
        else:
         
            # Perform swap
            temp = a[j]
            a[j] = a[min]
            a[min] = temp
 
            # Decrement i
            j -= 1
 
            # Assign the value of min
            min = j
         
        x += 1
     
    # Print the array
    for i in range (N):
        print (a[i] ,end = " ")
 
# Driver Code
if __name__ == "__main__":
   
    # Given Array arr[]
    arr = [1, 3, 3, 4, 5]
     
    N = len(arr)
     
    # Function call
    rearrange(arr, N)
     
# This code is contributed by Chitranayal
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function to perform the rearrangement
static void rearrange(int[] a)
{
     
    // Initialize variables
    int i = 0, j = a.Length - 1;
    int min = 0, k, x = 0, temp;
 
    // Loop until i crosses j
    while (i < j)
    {
         
        // This check is to find the
        // minimum values in the
        // ascending order
 
        for(k = i; k <= j; k++)
        {
            if (a[k] < a[min])
                min = k;
        }
 
        // Condition to alternatively
        // iterate variable i and j
        if (x % 2 == 0)
        {
             
            // Perform swap operation
            temp = a[i];
            a[i] = a[min];
            a[min] = temp;
 
            // Increment i
            i++;
 
            // Assign the value of min
            min = i;
        }
        else
        {
             
            // Perform swap
            temp = a[j];
            a[j] = a[min];
            a[min] = temp;
 
            // Decrement i
            j--;
 
            // Assign the value of min
            min = j;
        }
        x++;
    }
     
    // Print the array
    for(i = 0; i < a.Length; i++)
        Console.Write(a[i] + " ");
}
 
// Driver Code
public static void Main(string[] args)
{
     
    // Given array arr[]
    int []arr = { 1, 3, 3, 4, 5 };
 
    // Function call
    rearrange(arr);
}
}
 
// This code is contributed by rutvik_56
Javascript



<script>
// javascript program for the above approach
 
 
    // Function to perform the rearrangement
    function rearrange(a) {
        // Initialize variables
        var i = 0, j = a.length - 1;
        var min = 0, k, x = 0, temp;
 
        // Loop until i crosses j
        while (i < j) {
 
            // This check is to find the
            // minimum values in the
            // ascending order
 
            for (k = i; k <= j; k++) {
                if (a[k] < a[min])
                    min = k;
            }
 
            // Condition to alternatively
            // iterate variable i and j
            if (x % 2 == 0) {
 
                // Perform swap operation
                temp = a[i];
                a[i] = a[min];
                a[min] = temp;
 
                // Increment i
                i++;
 
                // Assign the value of min
                min = i;
            } else {
 
                // Perform swap
                temp = a[j];
                a[j] = a[min];
                a[min] = temp;
 
                // Decrement i
                j--;
 
                // Assign the value of min
                min = j;
            }
            x++;
        }
 
        // Print the array
        for (i = 0; i < a.length; i++)
            document.write(a[i] + " ");
    }
 
    // Driver Code
     
        // Given Array arr
        var arr = [ 1, 3, 3, 4, 5 ];
 
        // Function Call
        rearrange(arr);
 
// This code is contributed by todaysgaurav
</script>
Output: 
1 3 5 4 3
 
Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Difference between Linux and Inferno
Next

Quick Sort using Multi-threading
Recommended Articles
Page :
Arrange array elements such that last digit of an element is equal to first digit of the next element
29, Apr 19
Generate an N-length array A[] from an array arr[] such that arr[i] is the last index consisting of a multiple of A[i]
16, Feb 21
Minimize deletions such that no even index Array element is same as next element
01, Apr 22
Find next Smaller of next Greater in an array
10, Dec 16
Queries for number of distinct elements from a given index till last index in an array
17, Jun 19
Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element
23, Feb 21
Last seen array element (last appearance is earliest)
19, Nov 17
Comparison among Bubble Sort, Selection Sort and Insertion Sort
01, Apr 19
Rearrange array such that even index elements are smaller and odd index elements are greater
08, Oct 17
Minimize swaps required to place largest and smallest array elements at first and last array indices
28, Jan 21
Maximum element in an array such that its previous and next element product is maximum
02, Jul 19
Lexicographically smallest permutation of Array such that prefix sum till any index is not equal to K
30, Jun 21
Sort an array having first N elements sorted and last M elements are unsorted
15, Jun 21
Convert an array into another by repeatedly removing the last element and placing it at any arbitrary index
31, Mar 21
Number of permutations such that sum of elements at odd index and even index are equal
02, Jul 18
Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively
23, Mar 21
How to find last index of a number in an Array in C++
09, May 20
Check if every index i has an index j such that sum of elements in both directions are equal
04, Oct 18
Maximize score by rearranging Array such that absolute difference of first and last element is minimum
16, Nov 21
Minimize last remaining element of Array by selecting pairs such that arr[i] >= arr[j] and replace arr[i] with arr[i] - arr[j]
27, Jan 22
Longest Subsequence where index of next element is arr[arr[i] + i]
20, Dec 18
Find the index at which bit must be set to maximise distance between next set bit
26, Jan 22
Find the last positive element remaining after repeated subtractions of smallest positive element from all Array elements
10, Sep 21
Sum of elements till the smallest index such that there are no even numbers to its right
03, Sep 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
sankarramaswamy2000
@sankarramaswamy2000
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!