Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Program to print an array in Pendulum Arrangement with constant space

Given an array arr[] of integers, the task is to arrange them in a way similar to the to-and-fro movement of a Pendulum without using any extra space.
Pendulum Arrangement

• The minimum element out of the list of integers must come in the center position of the array.
• The number in the ascending order next to the minimum, goes to the right, the next higher number goes to the left of minimum number and it continues.
• As higher numbers are reached, one goes to one side in a to-and-fro manner similar to that of a Pendulum.

Examples:

Input: arr[] = {2, 3, 5, 1, 4}
Output: 5 3 1 2 4
The minimum element is 1, so it is moved to the middle.
The next higher element 2 is moved to the right of the
middle element while the next higher element 3 is
moved to the left of the middle element and
this process is continued.
Input: arr[] = {11, 2, 4, 55, 6, 8}
Output: 11 6 2 4 8 55

Approach: An approach which uses an auxiliary array has been discussed in this article. Here’s an approach without using extra space:

1. Sort the given array.
2. Move all the odd position element in the right side of the array.
3. Reverse the element from 0 to (n-1)/2 position of the array.

For example, let arr[] = {2, 3, 5, 1, 4}
Sorted array will be arr[] = {1, 2, 3, 4, 5}.
After moving all odd index position elements to the right,
arr[] = {1, 3, 5, 2, 4} (1 and 3 are the odd index positions)
After reversing elements from 0 to (n – 1) / 2,
arr[] = {5, 3, 1, 2, 4} which is the required array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the Pendulum``// arrangement of the given array``void` `pendulumArrangement(``int` `arr[], ``int` `n)``{``    ``// Sort the array``    ``sort(arr, arr + n);` `    ``int` `odd, temp, in, pos;` `    ``// pos stores the index of``    ``// the last element of the array``    ``pos = n - 1;` `    ``// odd stores the last odd index in the array``    ``if` `(n % 2 == 0)``        ``odd = n - 1;``    ``else``        ``odd = n - 2;` `    ``// Move all odd index positioned``    ``// elements to the right``    ``while` `(odd > 0) {``        ``temp = arr[odd];``        ``in = odd;` `        ``// Shift the elements by one position``        ``// from odd to pos``        ``while` `(in != pos) {``            ``arr[in] = arr[in + 1];``            ``in++;``        ``}``        ``arr[in] = temp;``        ``odd = odd - 2;``        ``pos = pos - 1;``    ``}` `    ``// Reverse the element from 0 to (n - 1) / 2``    ``int` `start = 0, end = (n - 1) / 2;` `    ``for` `(; start < end; start++, end--) {``        ``temp = arr[start];``        ``arr[start] = arr[end];``        ``arr[end] = temp;``    ``}` `    ``// Printing the pendulum arrangement``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 11, 2, 4, 55, 6, 8 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``pendulumArrangement(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.Arrays;``import` `java.io.*;` `class` `GFG {` `    ``// Function to print the Pendulum``    ``// arrangement of the given array``    ``static` `void` `pendulumArrangement(``int` `arr[], ``int` `n)``    ``{``        ``// Sort the array``        ``// sort(arr, arr + n);` `        ``Arrays.sort(arr);` `        ``int` `odd, temp, in, pos;` `        ``// pos stores the index of``        ``// the last element of the array``        ``pos = n - ``1``;` `        ``// odd stores the last odd index in the array``        ``if` `(n % ``2` `== ``0``)``            ``odd = n - ``1``;``        ``else``            ``odd = n - ``2``;` `        ``// Move all odd index positioned``        ``// elements to the right``        ``while` `(odd > ``0``) {``            ``temp = arr[odd];``            ``in = odd;` `            ``// Shift the elements by one position``            ``// from odd to pos``            ``while` `(in != pos) {``                ``arr[in] = arr[in + ``1``];``                ``in++;``            ``}``            ``arr[in] = temp;``            ``odd = odd - ``2``;``            ``pos = pos - ``1``;``        ``}` `        ``// Reverse the element from 0 to (n - 1) / 2``        ``int` `start = ``0``, end = (n - ``1``) / ``2``;` `        ``for` `(; start < end; start++, end--) {``            ``temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``        ``}` `        ``// Printing the pendulum arrangement``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `arr[] = { ``11``, ``2``, ``4``, ``55``, ``6``, ``8` `};``        ``int` `n = arr.length;` `        ``pendulumArrangement(arr, n);``    ``}``}` `// This code is contributed by akt_mit`

## Python3

 `# Python 3 implementation of the approach` `# Function to print the Pendulum``# arrangement of the given array``def` `pendulumArrangement(arr, n):``    ` `    ``# Sort the array``    ``arr.sort(reverse ``=` `False``)` `    ``# pos stores the index of``    ``# the last element of the array``    ``pos ``=` `n ``-` `1` `    ``# odd stores the last odd index in the array``    ``if` `(n ``%` `2` `=``=` `0``):``        ``odd ``=` `n ``-` `1``    ``else``:``        ``odd ``=` `n ``-` `2` `    ``# Move all odd index positioned``    ``# elements to the right``    ``while` `(odd > ``0``):``        ``temp ``=` `arr[odd]``        ``in1 ``=` `odd` `        ``# Shift the elements by one position``        ``# from odd to pos``        ``while` `(in1 !``=` `pos):``            ``arr[in1] ``=` `arr[in1 ``+` `1``]``            ``in1 ``+``=` `1` `        ``arr[in1] ``=` `temp``        ``odd ``=` `odd ``-` `2``        ``pos ``=` `pos ``-` `1` `    ``# Reverse the element from 0 to (n - 1) / 2``    ``start ``=` `0``    ``end ``=` `int``((n ``-` `1``) ``/` `2``)` `    ``while``(start < end):``        ``temp ``=` `arr[start]``        ``arr[start] ``=` `arr[end]``        ``arr[end] ``=` `temp``        ``start ``+``=` `1``        ``end ``-``=` `1` `    ``# Printing the pendulum arrangement``    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``11``, ``2``, ``4``, ``55``, ``6``, ``8``]``    ``n ``=` `len``(arr)` `    ``pendulumArrangement(arr, n)` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to print the Pendulum``    ``// arrangement of the given array``    ``static` `void` `pendulumArrangement(``int``[] arr, ``int` `n)``    ``{``        ``// Sort the array``        ``// sort(arr, arr + n);` `        ``Array.Sort(arr);` `        ``int` `odd, temp, p, pos;` `        ``// pos stores the index of``        ``// the last element of the array``        ``pos = n - 1;` `        ``// odd stores the last odd index in the array``        ``if` `(n % 2 == 0)``            ``odd = n - 1;``        ``else``            ``odd = n - 2;` `        ``// Move all odd index positioned``        ``// elements to the right``        ``while` `(odd > 0)``        ``{``            ``temp = arr[odd];``            ``p = odd;` `            ``// Shift the elements by one position``            ``// from odd to pos``            ``while` `(p != pos)``            ``{``                ``arr[p] = arr[p + 1];``                ``p++;``            ``}``            ``arr[p] = temp;``            ``odd = odd - 2;``            ``pos = pos - 1;``        ``}` `        ``// Reverse the element from 0 to (n - 1) / 2``        ``int` `start = 0, end = (n - 1) / 2;` `        ``for` `(; start < end; start++, end--)``        ``{``            ``temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``        ``}` `        ``// Printing the pendulum arrangement``        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(arr[i] + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 11, 2, 4, 55, 6, 8 };``        ``int` `n = arr.Length;` `        ``pendulumArrangement(arr, n);``    ``}``}` `// This code is contributed by ChitraNayal`

## PHP

 ` 0)``    ``{``        ``\$temp` `= ``\$arr``[``\$odd``];``        ``\$in` `= ``\$odd``;` `        ``// Shift the elements by one position``        ``// from odd to pos``        ``while` `(``\$in` `!= ``\$pos``)``        ``{``            ``\$arr``[``\$in``] = ``\$arr``[``\$in` `+ 1];``            ``\$in``++;``        ``}``        ``\$arr``[``\$in``] = ``\$temp``;``        ``\$odd` `= ``\$odd` `- 2;``        ``\$pos` `= ``\$pos` `- 1;``    ``}` `    ``// Reverse the element from 0 to (n - 1) / 2``    ``\$start` `= 0;``    ``\$end` `= ``floor``((``\$n` `- 1) / 2);` `    ``for` `(; ``\$start` `< ``\$end``; ``\$start``++, ``\$end``--)``    ``{``        ``\$temp` `= ``\$arr``[``\$start``];``        ``\$arr``[``\$start``] = ``\$arr``[``\$end``];``        ``\$arr``[``\$end``] = ``\$temp``;``    ``}` `    ``// Printing the pendulum arrangement``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``        ``echo` `\$arr``[``\$i``], ``" "``;``}` `// Driver code``\$arr` `= ``array``( 11, 2, 4, 55, 6, 8 );``\$n` `= ``count``(``\$arr``);` `pendulumArrangement(``\$arr``, ``\$n``);` `// This code is contributed by AnkitRai01` `?>`

## Javascript

 ``

Output:

`11 6 2 4 8 55`

Time Complexity: O(n2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up