Related Articles

# Check if an array can be sorted by swapping adjacent elements such that each element is swapped even number of times

• Last Updated : 10 Aug, 2021

Given an array arr[] consisting of N integers, the task is to check if the array can be sorted by swapping adjacent elements any number of times such that each array element is swapped even a number of times.

Examples:

Input: arr[] = {4, 3, 2, 5}
Output: Yes
Explanation:
Below are the possible order of swapping to make the array sorted:

1. Choose the indices 0 and 1 modifies the array to [3, 4, 2, 5]. Now, the frequency of swapping of {2, 3, 4, 5} is {0, 1, 1, 0} respectively.
2. Choose the indices 1 and 2 modifies the array to [3, 2, 4, 5]. Now, the frequency of swapping of {2, 3, 4, 5} is {1, 1, 2, 0} respectively.
3. Choose the indices 0 and 1 modifies the array to [2, 3, 4, 5]. Now, the frequency of swapping of {2, 3, 4, 5} is {2, 2, 2, 0} respectively.

Therefore, every array element is swapped even number of times and the given array is sorted. Hence, print Yes.

Input: arr[] = {1, 2, 3, 5, 4}
Output: No

Approach: The given problem can be solved by observing the fact that two adjacent even or odd indices elements can be swapped as there is no restriction on the number of swapping without changing the middle element. Therefore, the idea is to rearrange the array element at respective even and odd indices and check if the array formed is sorted or not. Follow the steps below to solve the given problem:

• Store all the array elements arr[i] at the odd indices in another array say odd[].
• Store all the array elements arr[i] at the even indices in another array say even[].
• Sort the arrays odd[] and even[] in increasing order.
• initialize two variables, say j and k as 0 that is used to traverse the arrays odd[] and even[].
• Iterate over the range [0, N] using the variable i and perform the following steps:
• If the value of i is odd, then push the element odd[j] in the array res[] and increment the value of j by 1.
• If the value of i is even, then push the element even[k] in the array res[] and increment the value of j by 1.
• After completing the above steps, if the array res[] is sorted, then print Yes. Otherwise, print No.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``#include ``using` `namespace` `std;` `// Function to check if the array can be``// made sorted by adjacent swapping of``// element such that each array element``// is swapped even number of times``bool` `isSorted(``int` `arr[], ``int` `n)``{``    ``vector<``int``> evenArr, oddArr;` `    ``// Traverse the given array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Stores all the even positions``        ``// elements``        ``if` `(i % 2 == 0)``            ``evenArr.push_back(arr[i]);` `        ``// Stores all the odd positions``        ``// elements``        ``else``            ``oddArr.push_back(arr[i]);``    ``}` `    ``// Sort the array evenArr[]``    ``sort(evenArr.begin(), evenArr.end());` `    ``// Sort the array oddArr[]``    ``sort(oddArr.begin(), oddArr.end());` `    ``int` `j = 0, k = 0;``    ``vector<``int``> res;` `    ``// Combine the elements from evenArr``    ``// and oddArr in the new array res[]``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(i % 2 == 0)``            ``res.push_back(evenArr[j]), j++;``        ``else``            ``res.push_back(oddArr[k]), k++;``    ``}` `    ``// Check if the array res[] is``    ``// sorted or not``    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``if` `(res[i] > res[i + 1])``            ``return` `false``;``    ``}` `    ``// Otherwise, return true``    ``return` `true``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 3, 2, 5 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``if` `(isSorted(arr, N)) {``        ``cout << ``"Yes"``;``    ``}``    ``else` `{``        ``cout << ``"No"``;``    ``}` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to check if the array can be``// made sorted by adjacent swapping of``// element such that each array element``// is swapped even number of times``static` `boolean` `isSorted(``int` `arr[], ``int` `n)``{``    ``Vector evenArr = ``new` `Vector();``    ``Vector oddArr = ``new` `Vector();` `    ``// Traverse the given array``    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``// Stores all the even positions``        ``// elements``        ``if` `(i % ``2` `== ``0``)``            ``evenArr.add(arr[i]);` `        ``// Stores all the odd positions``        ``// elements``        ``else``            ``oddArr.add(arr[i]);``    ``}` `    ``// Sort the array evenArr[]``    ``Collections.sort(evenArr);` `    ``// Sort the array oddArr[]``    ``Collections.sort(oddArr);` `    ``int` `j = ``0``, k = ``0``;``    ``Vector res=``new` `Vector();;` `    ``// Combine the elements from evenArr``    ``// and oddArr in the new array res[]``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``if` `(i % ``2` `== ``0``) {``            ``res.add(evenArr.get(j)); j++;``        ``}``        ``else` `{``            ``res.add(oddArr.get(k)); k++;``        ``}``    ``}` `    ``// Check if the array res[] is``    ``// sorted or not``    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``        ``if` `(res.get(i) > res.get(i + ``1``))``            ``return` `false``;``    ``}` `    ``// Otherwise, return true``    ``return` `true``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``4``, ``3``, ``2``, ``5` `};``    ``int` `N = arr.length;` `    ``if` `(isSorted(arr, N)) {``        ``System.out.print(``"Yes"``);``    ``}``    ``else` `{``        ``System.out.print(``"No"``);``    ``}` `}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `# Function to check if the array can be``# made sorted by adjacent swapping of``# element such that each array element``# is swapped even number of times``def` `isSorted(arr, n):``    ` `    ``evenArr ``=` `[]``    ``oddArr ``=` `[]` `    ``# Traverse the given array``    ``for` `i ``in` `range``(n):``        ` `        ``# Stores all the even positions``        ``# elements``        ``if` `(i ``%` `2` `=``=` `0``):``            ``evenArr.append(arr[i])` `        ``# Stores all the odd positions``        ``# elements``        ``else``:``            ``oddArr.append(arr[i])` `    ``# Sort the array evenArr[]``    ``evenArr.sort()` `    ``# Sort the array oddArr[]``    ``oddArr.sort()` `    ``j ``=` `0``    ``k ``=` `0``    ``res ``=` `[]` `    ``# Combine the elements from evenArr``    ``# and oddArr in the new array res[]``    ``for` `i ``in` `range``(n):``        ``if` `(i ``%` `2` `=``=` `0``):``            ``res.append(evenArr[j])``            ``j ``+``=` `1``        ``else``:``            ``res.append(oddArr[k])``            ``k ``+``=` `1` `    ``# Check if the array res[] is``    ``# sorted or not``    ``for` `i ``in` `range``(n ``-` `1``):``        ``if` `(res[i] > res[i ``+` `1``]):``            ``return` `False` `    ``# Otherwise, return true``    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``4``, ``3``, ``2``, ``5` `]``    ``N ``=` `len``(arr)` `    ``if` `(isSorted(arr, N)):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)``        ` `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``  ` `    ``// Function to check if the array can be``    ``// made sorted by adjacent swapping of``    ``// element such that each array element``    ``// is swapped even number of times``    ``static` `bool` `isSorted(``int``[] arr, ``int` `n)``    ``{``        ``List<``int``> evenArr = ``new` `List<``int``>();``        ``List<``int``> oddArr = ``new` `List<``int``>();` `        ``// Traverse the given array``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// Stores all the even positions``            ``// elements``            ``if` `(i % 2 == 0)``                ``evenArr.Add(arr[i]);` `            ``// Stores all the odd positions``            ``// elements``            ``else``                ``oddArr.Add(arr[i]);``        ``}` `        ``// Sort the array evenArr[]``        ``evenArr.Sort();` `        ``// Sort the array oddArr[]``        ``oddArr.Sort();` `        ``int` `j = 0, k = 0;``        ``List<``int``> res = ``new` `List<``int``>();` `        ``// Combine the elements from evenArr``        ``// and oddArr in the new array res[]``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(i % 2 == 0) {``                ``res.Add(evenArr[j]);``                ``j++;``            ``}``            ``else` `{``                ``res.Add(oddArr[k]);``                ``k++;``            ``}``        ``}` `        ``// Check if the array res[] is``        ``// sorted or not``        ``for` `(``int` `i = 0; i < n - 1; i++) {``            ``if` `(res[i] > res[i + 1])``                ``return` `false``;``        ``}` `        ``// Otherwise, return true``        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 4, 3, 2, 5 };``        ``int` `N = arr.Length;` `        ``if` `(isSorted(arr, N)) {``            ``Console.Write(``"Yes"``);``        ``}``        ``else` `{``            ``Console.Write(``"No"``);``        ``}``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up