Related Articles

# Check if the array can be sorted only if the elements on given positions can be swapped

• Last Updated : 29 Apr, 2021

Given an array arr[] of length N and another array P[] containing {a1, a2, … ak} which represents the positions of the given array arr[], the task is to check if the array can be sorted by only swapping the elements’ arr[ai], arr[ai+1] where ‘i’ is some element in the array P[].
Examples:

Input: arr[] = {3, 2, 1}, P[] = {1, 2}
Output: Yes
Explanation:
Initially, i = 1 (i.e.) first element and second element are swapped. Therefore, arr <=> arr. arr[] = {2, 3, 1}.
Similarly, i = 2 (i.e.) second element and third element are swapped. arr[] = {2, 1, 3}.
Finally, i = 1 (i.e.) first element and second element are swapped. arr[] = {1, 2, 3}.
Since this array is sorted, therefore, the given array can be sorted.
Input: arr[] = {5, 3, -4, 1, 12}, P[] = {2, 4, 3}
Output: No

Approach: The idea is to use two pointer approach to check if the array can be sorted or not.

• Initially, we create a position array pos[] of size N. This array will be used to mark the given positions in the array P[]. That is:
```if j = ai (1 ≤ i ≤ K)
then the element pos[ai-1] will be 1
else 0```
• Now, iterate through the array and check if pos[i] = 1 or not.
• If we encounter the pos[i]=1, we store the iterator in a temporary variable, and then we increment the iterator with value 1, till we have pos[i]=1 continuously, i.e.,
```j = i
while (j < N and pos[j])
j=j+1```
• After this increment, we sort this segment that we obtained from i to j+1 and finally, check after the position j, in the vector that we have to check, because we have sorted till this segment.
```Sort(arr[i] to arr[j+1])
i=j```
• Finally, after this loop completion, we have to check if the array has been sorted or not.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if the array``// can be sorted only if the elements``// on the given positions can be swapped` `#include ``using` `namespace` `std;` `// Function to check if the array can``// be sorted only if the elements on``// the given positions can be swapped``void` `check_vector(vector<``int``> A, ``int` `n,``                ``vector<``int``> p)``{` `    ``// Creating an array for marking``    ``// the positions``    ``vector<``int``> pos(A.size());` `    ``// Iterating through the array and``    ``// mark the positions``    ``for` `(``int` `i = 0; i < p.size(); i++) {``        ``pos[p[i] - 1] = 1;``    ``}` `    ``int` `flag = 1;` `    ``// Iterating through the given array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(pos[i] == 0)``            ``continue``;``        ``int` `j = i;` `        ``// If pos[i] is 1, then incrementing``        ``// till 1 is continuously present in pos``        ``while` `(j < n && pos[j])``            ``++j;` `        ``// Sorting the required segment``        ``sort(A.begin() + i, A.begin() + j + 1);``        ``i = j;``    ``}` `    ``// Checking if the vector is sorted or not``    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``if` `(A[i] > A[i + 1]) {``            ``flag = 0;``            ``break``;``        ``}``    ``}` `    ``// Print yes if it is sorted``    ``if` `(flag == 1)``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;``}` `// Driver code``int` `main()``{``    ``vector<``int``> A{ 3, 2, 1 };``    ``vector<``int``> p{ 1, 2 };` `    ``check_vector(A, A.size(), p);``    ``return` `0;``}`

## Java

 `// Java program to check if the array``// can be sorted only if the elements``// on the given positions can be swapped``import` `java.util.Arrays;` `class` `GFG{``    ` `// Function to check if the array can``// be sorted only if the elements on``// the given positions can be swapped``public` `static` `void` `check_vector(``int``[] A,``                                ``int` `n,``                                ``int``[] p)``{` `    ``// Creating an array for marking``    ``// the positions``    ``int``[] pos = ``new` `int``[A.length];` `    ``// Iterating through the array and``    ``// mark the positions``    ``for``(``int` `i = ``0``; i < p.length; i++)``    ``{``        ``pos[p[i] - ``1``] = ``1``;``    ``}` `    ``int` `flag = ``1``;` `    ``// Iterating through the given array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(pos[i] == ``0``)``            ``continue``;``            ` `        ``int` `j = i;` `        ``// If pos[i] is 1, then incrementing``        ``// till 1 is continuously present in pos``        ``while` `(j < n && pos[j] != ``0``)``            ``++j;` `        ``// Sorting the required segment``        ``Arrays.sort(A, i, j + ``1``);``        ``i = j;``    ``}` `    ``// Checking if the vector is sorted or not``    ``for``(``int` `i = ``0``; i < n - ``1``; i++)``    ``{``        ``if` `(A[i] > A[i + ``1``])``        ``{``            ``flag = ``0``;``            ``break``;``        ``}``    ``}` `    ``// Print yes if it is sorted``    ``if` `(flag == ``1``)``        ``System.out.print(``"Yes"``);``    ``else``        ``System.out.print(``"No"``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``3``, ``2``, ``1` `};``    ``int` `p[] = { ``1``, ``2` `};``    ` `    ``check_vector(A, A.length, p);``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to check if the array``# can be sorted only if the elements``# on the given positions can be swapped` `# Function to check if the array can``# be sorted only if the elements on``# the given positions can be swapped``def` `check_vector(A, n, p):``    ` `    ``# Creating an array for marking``    ``# the positions``    ``pos ``=` `[``0` `for` `i ``in` `range``(``len``(A))]` `    ``# Iterating through the array and``    ``# mark the positions``    ``for` `i ``in` `range``(``len``(p)):``        ``pos[p[i] ``-` `1``] ``=` `1` `    ``flag ``=` `1` `    ``# Iterating through the given array``    ``for` `i ``in` `range``(n):``        ``if` `(pos[i] ``=``=` `0``):``            ``continue``        ``j ``=` `i` `        ``# If pos[i] is 1, then incrementing``        ``# till 1 is continuously present in pos``        ``while` `(j < n ``and` `pos[j]):``            ``j ``+``=` `1` `        ``# Sorting the required segment``        ``p ``=` `A[: i]``        ``q ``=` `A[i : i ``+` `j ``+` `1``]``        ``r ``=` `A[i ``+` `j ``+` `1` `: ``len``(A)]``        ` `        ``q.sort(reverse ``=` `False``)``        ``A ``=` `p ``+` `q ``+` `r``        ``i ``=` `j` `    ``# Checking if the vector is sorted or not``    ``for` `i ``in` `range``(n ``-` `1``):``        ``if` `(A[i] > A[i ``+` `1``]):``            ``flag ``=` `0``            ``break` `    ``# Print yes if it is sorted``    ``if` `(flag ``=``=` `1``):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``);` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``A ``=` `[ ``3``, ``2``, ``1` `]``    ``p ``=` `[ ``1``, ``2` `]` `    ``check_vector(A,``len``(A), p)` `# This code is contributed by Samarth`

## C#

 `// C# program to check``// if the array can be``// sorted only if the``// elements on the given``// positions can be swapped``using` `System;``class` `GFG{``    ` `// Function to check if the array can``// be sorted only if the elements on``// the given positions can be swapped``public` `static` `void` `check_vector(``int``[] A,``                                ``int` `n,``                                ``int``[] p)``{``  ``// Creating an array for marking``  ``// the positions``  ``int``[] pos = ``new` `int``[A.Length];` `  ``// Iterating through the array and``  ``// mark the positions``  ``for``(``int` `i = 0; i < p.Length; i++)``  ``{``    ``pos[p[i] - 1] = 1;``  ``}` `  ``int` `flag = 1;` `  ``// Iterating through the given array``  ``for``(``int` `i = 0; i < n; i++)``  ``{``    ``if` `(pos[i] == 0)``      ``continue``;` `    ``int` `j = i;` `    ``// If pos[i] is 1, then``    ``// incrementing till 1``    ``// is continuously present in pos``    ``while` `(j < n && pos[j] != 0)``      ``++j;` `    ``// Sorting the required segment``    ``Array.Sort(A, i, j + 1);``    ``i = j;``  ``}` `  ``// Checking if the vector``  ``// is sorted or not``  ``for``(``int` `i = 0; i < n - 1; i++)``  ``{``    ``if` `(A[i] > A[i + 1])``    ``{``      ``flag = 0;``      ``break``;``    ``}``  ``}` `  ``// Print yes if it is sorted``  ``if` `(flag == 1)``    ``Console.Write(``"Yes"``);``  ``else``    ``Console.Write(``"No"``);``}` `// Driver code``public` `static` `void` `Main()``{``  ``int``[] A = {3, 2, 1};``  ``int``[] p = {1, 2};``  ``check_vector(A, A.Length, p);``}``}` `// This code is contributed by Chitranayal`

## Javascript

 ``
Output:

`Yes`

Time Complexity: O(N * log(N)), where N is the size of the array.

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