Rearrange an array such that every odd indexed element is greater than it previous
Last Updated :
12 Jul, 2022
Given an unsorted array, rearrange the array such that the number at the odd index is greater than the number at the previous even index. There may be multiple outputs, we need to print one of them.
Note: Indexing is based on an array, so it always starts from 0.
Examples:
Input : arr[] = {5, 2, 3, 4}
Output : arr[] = {2, 5, 3, 4}
Input : arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}
Output : arr[] = {1, 3, 2, 5, 4, 7, 6, 9, 8}
If the given array has an even length, then it can be done in a single run. Just for each pair of neighbors, put the max in odd position and min in even. So we just start a cycle from the beginning and compare every two elements. Let’s say
6, 5, 4, 3, 2, 1 will give us 5, 6, 3, 4, 1, 2
If the array has an odd length, like 6, 5, 4, 3, 2, 1, 100 then it’s slightly trickier, we need to run the second, backward cycle again, but starting from the last element. So, 6, 5, 4, 3, 2, 1, 100 after first cycle will be 5, 6, 3, 4, 1, 2, 100 and after second cycle 5, 6, 3, 4, 1, 100, 2
Implementation:
C++
#include<bits/stdc++.h>
using namespace std;
void rearrange(int arr[], int n)
{
for (int i=0; i<n-1; i=i+2)
{
if (arr[i] > arr[i+1])
swap(arr[i], arr[i+1]);
}
if (n & 1)
{
for (int i=n-1; i>0; i=i-2)
if (arr[i] > arr[i-1])
swap(arr[i], arr[i-1]);
}
}
void printArray(int arr[], int size)
{
for (int i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int n = sizeof(arr)/sizeof(arr[0]);
cout << "Before rearranging\n";
printArray(arr, n);
rearrange(arr, n);
cout << "After rearranging\n";
printArray(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
public static void swap(int[] arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void Rearrange(int[] arr, int n)
{
for (int i = 0; i < n - 1; i = i + 2) {
if (arr[i] > arr[i + 1])
swap(arr, i, i + 1);
}
if ((n & 1) > 0) {
for (int i = n - 1; i > 0; i = i - 2)
if (arr[i] > arr[i - 1])
swap(arr, i, i - 1);
}
}
public static void main(String[] args)
{
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
System.out.println("Before rearranging");
System.out.println(Arrays.toString(arr));
Rearrange(arr, arr.length);
System.out.println("After rearranging");
System.out.println(Arrays.toString(arr));
}
}
|
Python3
def rearrange(arr, n):
for i in range(0, n - 1, 2):
if (arr[i] > arr[i + 1]):
temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
if (n & 1):
i = n - 1
while(i > 0):
if (arr[i] > arr[i - 1]):
temp = arr[i]
arr[i] = arr[i - 1]
arr[i - 1] = temp
i -= 2
def printArray(arr, size):
for i in range(0, size, 1):
print(arr[i], end = " ")
print("\n")
if __name__ == '__main__':
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
n = len(arr)
print("Before rearranging")
printArray(arr, n)
rearrange(arr, n)
print("After rearranging")
printArray(arr, n)
|
C#
using System;
class GFG
{
public static void swap(int[] arr,
int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void Rearrange(int[] arr,
int n)
{
for (int i = 0; i < n - 1; i = i + 2)
{
if (arr[i] > arr[i + 1])
swap(arr, i, i + 1);
}
if ((n & 1) > 0)
{
for (int i = n - 1;
i > 0; i = i - 2)
if (arr[i] > arr[i - 1])
swap(arr, i, i - 1);
}
}
static void Main()
{
int[] arr = {1, 2, 3, 4,
5, 6, 7, 8, 9};
Console.WriteLine("Before rearranging");
for(int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Rearrange(arr, arr.Length);
Console.WriteLine("\nAfter rearranging");
for(int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
}
}
|
PHP
<?php
function rearrange(&$arr, $n)
{
for ($i = 0; $i < $n - 1; $i = $i + 2)
{
if ($arr[$i] > $arr[$i + 1])
{
$temp = $arr[$i];
$arr[$i] = $arr[$i + 1];
$arr[$i + 1] = $temp;
}
}
if ($n & 1)
{
for ($i = $n - 1; $i > 0; $i = $i - 2)
if ($arr[$i] > $arr[$i - 1])
{
$temp = $arr[$i];
$arr[$i] = $arr[$i - 1];
$arr[$i - 1] = $temp;
}
}
}
function printArray(&$arr, $size)
{
for ($i = 0; $i < $size; $i++)
echo $arr[$i] . " ";
echo "\n";
}
$arr = array(1, 2, 3, 4, 5, 6, 7, 8, 9);
$n = sizeof($arr);
echo "Before rearranging\n";
printArray($arr, $n);
rearrange($arr, $n);
echo "After rearranging\n";
printArray($arr, $n);
?>
|
Javascript
<script>
function swap(arr,i,j)
{
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function Rearrange(arr,n)
{
for (let i = 0; i < n - 1; i = i + 2) {
if (arr[i] > arr[i + 1])
swap(arr, i, i + 1);
}
if ((n & 1) > 0) {
for (let i = n - 1; i > 0; i = i - 2)
if (arr[i] > arr[i - 1])
swap(arr, i, i - 1);
}
}
let arr=[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
document.write("Before rearranging<br>");
for(let i=0;i<arr.length;i++)
{
document.write(arr[i]+" ");
}
document.write("<br>")
Rearrange(arr, arr.length);
document.write("After rearranging<br>");
for(let i=0;i<arr.length;i++)
{
document.write(arr[i]+" ");
}
</script>
|
Output
Before rearranging
1 2 3 4 5 6 7 8 9
After rearranging
1 3 2 5 4 7 6 9 8
Time Complexity: O(n)
Auxiliary Space: O(1)
Similar Reads
Rearrange given Array such that each element raised to its index is odd
Given an array arr of length N, the task is to rearrange the elements of given array such that for each element, its bitwise XOR with its index is an odd value. If no rearrangement is possible return -1. Example: Input: arr[] = {1 2 4 3 5}Output: 1 2 3 4 5Explanation: In the above array:for 1st elem
13 min read
Rearrange array such that even positioned are greater than odd
Given an array arr[], sort the array according to the following relations: arr[i] >= arr[i - 1], if i is even, ∀ 1 <= i < narr[i] <= arr[i - 1], if i is odd, ∀ 1 <= i < nFind the resultant array.[consider 1-based indexing] Examples: Input: arr[] = [1, 2, 2, 1]Output: [1 2 1 2] Expl
9 min read
Rearrange array such that all even-indexed elements in the Array is even
Given an array arr[], the task is to check if it is possible to rearrange the array in such a way that every even index(1-based indexing) contains an even number. If such a rearrangement is not possible, print "No". Otherwise, print "Yes" and print a possible arrangement Examples: Input: arr[] = {2,
6 min read
Rearrange array such that even index elements are smaller and odd index elements are greater
Given an array, rearrange the array such that : If index i is even, arr[i] <= arr[i+1]If index i is odd, arr[i] >= arr[i+1] Note: There can be multiple answers. Examples: Input : arr[] = {2, 3, 4, 5} Output : arr[] = {2, 4, 3, 5} Explanation : Elements at even indexes are smaller and elements
11 min read
Modify given array to make sum of odd and even indexed elements same
Given a binary array arr[] of size N, remove at most N/2 elements from the array such that the sum of elements at odd and even indices becomes equal. The task is to print the modified array.Note: N is always even. There can be more than one possible result, print any of them. Examples: Input: arr[]
10 min read
Rearrange an array such that product of every two consecutive elements is a multiple of 4
Given an array arr[] of size N, the task is to rearrange the array elements such that for every index i(1 <= i <= N - 1), the product of arr[i] and arr[i - 1] is a multiple of 4.Example: Input: arr[] = {1, 10, 100} Output: 1, 100, 10 Explanation: 1 * 100 is divisible by 4 100 * 10 is divisible
11 min read
Reverse a subarray to maximize sum of even-indexed elements of given array
Given an array arr[], the task is to maximize the sum of even-indexed elements by reversing a subarray and print the maximum sum obtained. Examples: Input: arr[] = {1, 2, 1, 2, 1} Output: 5 Explanation: Sum of initial even-indexed elements = a[0] + a[2] + a[4] = 1 + 1 + 1 = 3 Reversing subarray {1,
9 min read
Minimize swaps to rearrange array such that parity of index and corresponding element is same
Given an array A[], the task to find minimum swapping operations required to modify the given array A[] such that for every index in the array, parity(i) = parity(A[i]) where parity(x) = x % 2. If it's impossible to obtain such an arrangement, then print -1. Examples: Input: A[] = { 2, 4, 3, 1, 5, 6
6 min read
Rearrange Even and Odd Index Elements in K Operations
Given an array arr[] of size N (N is even) and a positive integer K, the task is to apply an operation to the array arr[] for K times. Applying the operation once will shift all the even indexed numbers to the beginning and all the odd indexed numbers to the end, maintaining their relative order. Ex
7 min read
Rearrange array by interchanging positions of even and odd elements in the given array
Given an array arr[] of N positive integers with an equal number of even and odd elements. The task is to use in-place swapping to interchange positions of even and odd elements in the array. Examples: Input: arr[] = {1, 3, 2, 4}Output: 2 4 1 3Explanation:Before rearranging the given array, indices
15+ min read