📌  相关文章
📜  检查数组是否只能在给定位置上的元素可以交换的情况下进行排序

📅  最后修改于: 2021-09-06 05:18:50             🧑  作者: Mango

给定一个长度为N的数组arr[]和另一个包含 {a 1 , a 2 , … a k } 的数组P[]代表给定数组 arr[] 的位置,任务是检查数组是否可以排序通过只交换元素’ arr[a i ], arr[a i+1 ] 其中’i’是数组P[]中的某个元素。
例子:

方法:这个想法是使用两个指针的方法来检查数组是否可以排序。

  • 最初,我们创建一个大小为N的位置数组pos[] 。该数组将用于标记数组P[] 中的给定位置。那是:
if j = ai (1 ≤ i ≤ K)
then the element pos[ai-1] will be 1
else 0
  • 现在,遍历数组并检查pos[i] = 1是否。
  • 如果我们遇到pos[i]=1 ,我们将迭代器存储在一个临时变量中,然后我们用值1递增迭代器,直到我们有pos[i]=1连续,即,
j = i
while (j < N and pos[j]) 
    j=j+1
  • 在这个增量之后,我们对我们从 i 到 j+1 获得的这个段进行排序,最后,在我们必须检查的向量中的位置 j 之后检查,因为我们已经排序到这个段。
Sort(arr[i] to arr[j+1])
i=j
  • 最后,在此循环完成后,我们必须检查数组是否已排序。

下面是上述方法的实现:

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 A, int n,
                vector p)
{
 
    // Creating an array for marking
    // the positions
    vector 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 A{ 3, 2, 1 };
    vector 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


输出:

Yes

时间复杂度: O(N * log(N)) ,其中 N 是数组的大小。

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live