每个数组元素在其排序位置的右移计数

给定一个大小为N的数组arr[] ，其中包含范围[1, N]中的元素，任务是计算如果数组已排序，每个元素到达其各自位置所需的右移次数。
例子：

Input: arr[] = {1, 4, 3, 2, 5}, N = 5 
Output: 0 2 0 3 0 
Explanation: 
The sorted array is {1, 2, 3, 4, 5}. 
4 is at index 1, so right shift 2 times to reach index 3. (1->2->3) 
2 is at index 3, so right shift 3 times to reach index 1. (3->4->0->1) 
All the other elements are at their respective positions in the sorted array.
Input: arr[]={2, 4, 3, 1, 5}, N = 5 
Output: 2 1 0 2 0 
 

方法：
这个想法是计算数组中每个元素的实际位置和排序位置之间的差异。由于元素从1到N，因此无需对数组进行排序即可确定每个元素的排序位置。每个元素的排序位置由(arr[i]-1) 给出。因此，右移的次数由(arr[i] – 1 – i + N) % N 给出。

下面是上述方法的实现：

C++

// C++ Program to implement
// the approach
#include 
using namespace std;
 
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in A[]
void findShifts(int A[], int N)
{
    // Stores required number of
    // shifts for each element
    int shift[N];
 
    for (int i = 0; i < N; i++) {
 
        // If the element is
        // at sorted position
        if (i == A[i] - 1)
            shift[i] = 0;
 
        // Otherwise
        else
 
            // Calculate right shift
            shift[i]
                = (A[i] - 1 - i + N)
                  % N;
    }
 
    // Print the respective shifts
    for (int i = 0; i < N; i++)
        cout << shift[i] << " ";
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 4, 3, 2, 5 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    findShifts(arr, N);
 
    return 0;
}

Java

// Java program to implement
// the approach
class GFG{
     
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in A[]
public static void findShifts(int[] A, int N)
{
     
    // Stores required number of
    // shifts for each element
    int[] shift = new int[N];
 
    for(int i = 0; i < N; i++)
    {
 
        // If the element is
        // at sorted position
        if (i == A[i] - 1)
            shift[i] = 0;
 
        // Otherwise
        else
 
            // Calculate right shift
            shift[i] = (A[i] - 1 - i + N) % N;
    }
 
    // Print the respective shifts
    for(int i = 0; i < N; i++)
        System.out.print(shift[i] + " ");
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 4, 3, 2, 5 };
    int N = arr.length;
 
    findShifts(arr, N);
}
}
 
// This code is contributed by divyeshrabadiya07

Python3

# Python3 Program to implement
# the approach
 
# Function to find the right
# shifts required for each
# element to reach its sorted
# array position in A[]
def findShifts(A, N):
 
    # Stores required number of
    # shifts for each element
    shift = [0 for i in range(N)]
 
    for i in range(N):
 
        # If the element is
        # at sorted position
        if (i == A[i] - 1):
            shift[i] = 0
 
        # Otherwise
        else:
 
            # Calculate right shift
            shift[i] = (A[i] - 1 - i + N) % N
 
    # Print the respective shifts
    for i in range(N):
        print(shift[i], end = " ")
 
# Driver Code
if __name__ == '__main__':
 
    arr = [ 1, 4, 3, 2, 5 ]
    N = len(arr)
 
    findShifts(arr, N)
 
# This code is contributed by mohit kumar 29

C#

// C# program to implement
// the approach
using System;
 
class GFG{
     
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in []A
public static void findShifts(int[] A, int N)
{
     
    // Stores required number of
    // shifts for each element
    int[] shift = new int[N];
 
    for(int i = 0; i < N; i++)
    {
 
        // If the element is
        // at sorted position
        if (i == A[i] - 1)
            shift[i] = 0;
 
        // Otherwise
        else
 
            // Calculate right shift
            shift[i] = (A[i] - 1 - i + N) % N;
    }
 
    // Print the respective shifts
    for(int i = 0; i < N; i++)
        Console.Write(shift[i] + " ");
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 4, 3, 2, 5 };
    int N = arr.Length;
 
    findShifts(arr, N);
}
}
 
// This code is contributed by amal kumar choubey

Javascript

// JavaScript program to implement
// the approach
 
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in A[]
function findShifts(A, N)
{
       
    // Stores required number of
    // shifts for each element
    let shift = Array.from({length: N}, (_, i) => 0);
   
    for(let i = 0; i < N; i++)
    {
   
        // If the element is
        // at sorted position
        if (i == A[i] - 1)
            shift[i] = 0;
   
        // Otherwise
        else
   
            // Calculate right shift
            shift[i] = (A[i] - 1 - i + N) % N;
    }
   
    // Prlet the respective shifts
    for(let i = 0; i < N; i++)
        document.write(shift[i] + " ");
}
 
// Driver Code   
     
    let arr = [ 1, 4, 3, 2, 5 ];
    let N = arr.length;
   
    findShifts(arr, N);
                               

输出：

0 2 0 3 0

时间复杂度： O(N)
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。