Check whether a given array is a k sorted array or not

Given an array of n distinct elements. Check whether the given array is a k sorted array or not. A k sorted array is an array where each element is at most k distance away from its target position in the sorted array.
For example, let us consider k is 2, an element at index 7 in the sorted array, can be at indexes 5, 6, 7, 8, 9 in the given array.

Examples :

Input : arr[] = {3, 2, 1, 5, 6, 4}, k = 2
Output : Yes
Every element is at most 2 distance away
from its target position in the sorted array.

Input : arr[] = {13, 8, 10, 7, 15, 14, 12}, k = 3
Output : No
13 is more than k = 3 distance away
from its target position in the sorted array.



Copy elements elements of original array arr[] to an auxiliary array aux[].
Sort aux[]. Now, for each element at index i in arr[], find its index j in aux[] using Binary Search. If for any element k < abs(i-j), then arr[] is not a k sorted array. Else it is a k sorted array. Here abs is the absolute value.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to check whether the given array
// is a k sorted array or not
#include <bits / stdc++.h>
using namespace std;
  
// function to find index of element 'x' in sorted 'arr'
// uses binary search technique
int binarySearch(int arr[], int low, int high, int x)
{
    while (low <= high)
    {
        int mid = (low + high) / 2;
          
        if (arr[mid] == x)
            return mid;
        else if (arr[mid] > x)
            high = mid - 1;
        else    
            low = mid + 1;    
    }
}
  
// function to check whether the given array is
// a 'k' sorted array or not
string isKSortedArray(int arr[], int n, int k)
{
    // auxiliary array 'aux'
    int aux[n];
      
    // copy elements of 'arr' to 'aux'
    for (int i = 0; i<n; i++)
        aux[i] = arr[i];
      
    // sort 'aux'    
    sort(aux, aux + n);
      
    // for every element of 'arr' at index 'i', 
    // find its index 'j' in 'aux'
    for (int i = 0; i<n; i++)
    {
        // index of arr[i] in sorted array 'aux'
        int j = binarySearch(aux, 0, n-1, arr[i]);
          
        // if abs(i-j) > k, then that element is
        // not at-most k distance away from its 
        // target position. Thus,  'arr' is not a 
        // k sorted array 
        if (abs(i - j) > k)
            return "No";
    }
      
    // 'arr' is a k sorted array
    return "Yes";    
}
  
// Driver program to test above
int main()
{
    int arr[] = {3, 2, 1, 5, 6, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << "Is it a k sorted array?: "
         << isKSortedArray(arr, n, k);
    return 0;     

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to check whether the given array
// is a k sorted array or not
  
import java.util.Arrays;
  
class Test
{
    // Method to check whether the given array is
    // a 'k' sorted array or not
    static String isKSortedArray(int arr[], int n, int k)
    {
        // auxiliary array 'aux'
        int aux[] = new int[n];
           
        // copy elements of 'arr' to 'aux'
        for (int i = 0; i<n; i++)
            aux[i] = arr[i];
           
        // sort 'aux'    
        Arrays.sort(aux);
           
        // for every element of 'arr' at index 'i', 
        // find its index 'j' in 'aux'
        for (int i = 0; i<n; i++)
        {
            // index of arr[i] in sorted array 'aux'
            int j = Arrays.binarySearch(aux,arr[i]);
               
            // if abs(i-j) > k, then that element is
            // not at-most k distance away from its 
            // target position. Thus,  'arr' is not a 
            // k sorted array 
            if (Math.abs(i - j) > k)
                return "No";
        }
           
        // 'arr' is a k sorted array
        return "Yes";    
    }
  
    // Driver method
    public static void main(String args[])
    {
        int arr[] = {3, 2, 1, 5, 6, 4};
        int k = 2;
          
        System.out.println("Is it a k sorted array ?: " +
                            isKSortedArray(arr, arr.length, k));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation to check 
# whether the given array is a k 
# sorted array or not
  
# function to find index of element 
# 'x' in sorted 'arr' uses binary 
# search technique
def binarySearch(arr, low, high, x):
    while (low <= high):
        mid = int((low + high) / 2)
          
        if (arr[mid] == x):
            return mid
        elif(arr[mid] > x):
            high = mid - 1
        else:
            low = mid + 1
  
# function to check whether the given 
# array is a 'k' sorted array or not
def isKSortedArray(arr, n, k):
      
    # auxiliary array 'aux'
    aux = [0 for i in range(n)]
      
    # copy elements of 'arr' to 'aux'
    for i in range(0, n, 1):
        aux[i] = arr[i]
      
    # sort 'aux' 
    aux.sort(reverse = False)
      
    # for every element of 'arr' at 
    # index 'i', find its index 'j' in 'aux'
    for i in range(0, n, 1):
          
        # index of arr[i] in sorted
        # array 'aux'
        j = binarySearch(aux, 0, n - 1, arr[i])
          
        # if abs(i-j) > k, then that element is
        # not at-most k distance away from its 
        # target position. Thus, 'arr' is not a 
        # k sorted array 
        if (abs(i - j) > k):
            return "No"
      
    # 'arr' is a k sorted array
    return "Yes"
  
# Driver Code
if __name__ == '__main__':
    arr = [3, 2, 1, 5, 6, 4]
    n = len(arr)
    k = 2
    print("Is it a k sorted array?:"
           isKSortedArray(arr, n, k))
  
# This code is contributed by
# Shashank_Sharma

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to check 
// whether the given array is a 
// k sorted array or not
using System;
using System.Collections;
  
class GFG {
      
    // Method to check whether the given
    // array is a 'k' sorted array or not
    static String isKSortedArray(int []arr, int n, int k)
    {
        // auxiliary array 'aux'
        int []aux = new int[n];
          
        // copy elements of 'arr' to 'aux'
        for (int i = 0; i<n; i++)
            aux[i] = arr[i];
          
        // sort 'aux' 
        Array.Sort(aux);
          
        // for every element of 'arr' at index
        // 'i', find its index 'j' in 'aux'
        for (int i = 0; i<n; i++)
        {
            // index of arr[i] in sorted array 'aux'
            int j = Array.BinarySearch(aux,arr[i]);
              
            // if abs(i-j) > k, then that element is
            // not at-most k distance away from its 
            // target position. Thus, 'arr' is not a 
            // k sorted array 
            if (Math.Abs(i - j) > k)
                return "No";
        }
          
        // 'arr' is a k sorted array
        return "Yes"
    }
  
    // Driver method
    public static void Main()
    {
        int []arr = {3, 2, 1, 5, 6, 4};
        int k = 2;
          
        Console.WriteLine("Is it a k sorted array ?: " +
                           isKSortedArray(arr, arr.Length, k));
    }
}
  
// This code is contributed by Sam007

chevron_right



Output:

Is it a k sorted array?: Yes

Time Complexity: O(nlogn)
Auxiliary space: O(n)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up

Improved By : Sam007, Shashank_Sharma