Skip to content
Related Articles

Related Articles

Sort integers in array according to their distance from the element K
  • Difficulty Level : Easy
  • Last Updated : 08 Sep, 2020

Given an array arr[] of N integers and an integer K, the task is to sort these integers according to their distance from given integer K. If more than 1 element is at the same distance, print them in increasing order.
Note: Distance between two elements in the array is measured as the difference between their index.
Note: The integer K is always present in array arr[] and is unique.
Examples:  

Input: arr[] = {12, 10, 102, 31, 15}, K = 102 
Output: 102 10 31 12 15 
Explanation: 
Elements at their respective distance from K are, 
At distance 0: 102 
At distance 1: 10, 31 in sorted form. 
At distance 2: 12, 15 in sorted form. 
Hence, our resultant array is [ 102, 10, 31, 12, 15 ]
Input: arr[] = {14, 1101, 10, 35, 0}, K = 35 
Output: 35 0 10 1101 14 
Explanation: 
Elements at their respective distance from K are, 
At distance 0: 35 
At distance 1: 10, 0 and in sorted form we have 0, 10. 
At distance 2: 1101 
At distance 3: 14 
Hence, our resultant array is [ 35, 0, 10, 1101, 14 ] 
 

Approach :
To solve the problem mentioned above we create an auxiliary vector to store elements at any distance from K. Then find the position of given integer K in the array arr[] and insert the element K at position 0 in the auxiliary vector. Traverse the array in the left direction from K and insert those elements in the vector at their distance from K. Repeat the above process for the right side elements of K. Finally, print the array elements from distance 0 in sorted order.
Below is the implementation of the above approach: 
 

C++




// C++ implementation to Sort the integers in
// array according to their distance from given
// element K present in the array
#include <bits/stdc++.h>
using namespace std;
 
// Function to get sorted array based on
// their distance from given integer K
void distanceSort(int arr[], int K, int n)
{
    // Vector to store respective elements
    // with their distance from integer K
    vector<int> vd[n];
 
    // Find the position of integer K
    int pos;
 
    for (int i = 0; i < n; i++) {
        if (arr[i] == K) {
            pos = i;
            break;
        }
    }
 
    // Insert the elements with their
    // distance from K in vector
 
    int i = pos - 1, j = pos + 1;
 
    // Element at distnce 0
    vd[0].push_back(arr[pos]);
 
    // Elements at left side of K
    while (i >= 0) {
        vd[pos - i].push_back(arr[i]);
        --i;
    }
 
    // Elements at right side of K
    while (j < n) {
        vd[j - pos].push_back(arr[j]);
        ++j;
    }
 
    // Print the vector content in sorted order
    for (int i = 0; i <= max(pos, n - pos - 1); ++i) {
 
        // Sort elements at same distance
        sort(begin(vd[i]), end(vd[i]));
 
        // Print elements at distance i from K
        for (auto element : vd[i])
            cout << element << " ";
    }
}
 
// Driver code
int main()
{
    int arr[] = {14, 1101, 10, 35, 0 }, K = 35;
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    distanceSort(arr, K, n);
 
    return 0;
}

Java




// Java implementation to Sort the integers in
// array according to their distance from given
// element K present in the array
import java.util.*;
 
class GFG{
     
// Function to get sorted array based on
// their distance from given integer K
@SuppressWarnings("unchecked")
static void distanceSort(int arr[], int K, int n)
{
     
    // Vector to store respective elements
    // with their distance from integer K
    Vector vd[] = new Vector[n];
     
    for(int i = 0; i < n; i++)
    {
        vd[i] = new Vector();
    }
     
    // Find the position of integer K
    int pos = 0;
  
    for(int i = 0; i < n; i++)
    {
        if (arr[i] == K)
        {
            pos = i;
            break;
        }
    }
  
    // Insert the elements with their
    // distance from K in vector
    int i = pos - 1, j = pos + 1;
  
    // Element at distnce 0
    vd[0].add(arr[pos]);
  
    // Elements at left side of K
    while (i >= 0)
    {
        vd[pos - i].add(arr[i]);
        --i;
    }
  
    // Elements at right side of K
    while (j < n)
    {
        vd[j - pos].add(arr[j]);
        ++j;
    }
  
    // Print the vector content in sorted order
    for(i = 0; i <= Math.max(pos, n - pos - 1); ++i)
    {
         
        // Sort elements at same distance
        Collections.sort(vd[i]);
  
        // Print elements at distance i from K
        for (j = 0; j < vd[i].size(); j++)
        {
            int element = (int)vd[i].get(j);
            System.out.print(element + " ");
        }
    }
}
     
// Driver Code
public static void main(String s[])
{
    int arr[] = {14, 1101, 10, 35, 0 };
    int K = 35;
 
    int n = arr.length;
 
    distanceSort(arr, K, n);
}   
}
 
// This code is contributed by rutvik_56

Python3




# Python3 implementation to Sort the integers in
# array according to their distance from given
# element K present in the array
 
# Function to get sorted array based on
# their distance from given integer K
def distanceSort(arr,K,n):
    # Vector to store respective elements
    # with their distance from integer K
    vd = [[] for i in range(n)]
 
    # Find the position of integer K
 
    for i in range(n):
        if (arr[i] == K):
            pos = i
            break
 
    # Insert the elements with their
    # distance from K in vector
 
    i = pos - 1
    j = pos + 1
 
    # Element at distnce 0
    vd[0].append(arr[pos])
 
    # Elements at left side of K
    while (i >= 0):
        vd[pos - i].append(arr[i])
        i -= 1
 
    # Elements at right side of K
    while (j < n):
        vd[j - pos].append(arr[j])
        j += 1
 
    # Print the vector content in sorted order
    for i in range(max(pos, n - pos - 1) + 1):
 
        # Sort elements at same distance
        vd[i].sort(reverse=False)
 
        # Print elements at distance i from K
        for element in vd[i]:
            print(element,end = " ")
 
# Driver code
if __name__ == '__main__':
    arr =  [14, 1101, 10, 35, 0]
    K = 35
 
    n = len(arr)
 
    distanceSort(arr, K, n)
 
# This code is contributed by Surendra_Gangwar

C#




// C# implementation to Sort the integers in
// array according to their distance from given
// element K present in the array
using System;
using System.Collections.Generic;
class GFG{
     
// Function to get sorted array based on
// their distance from given integer K
static void distanceSort(int []arr,
                         int K, int n)
{   
    // List to store respective elements
    // with their distance from integer K
    List<int> []vd = new List<int>[n];
    int i ;
    for(i = 0; i < n; i++)
    {
        vd[i] = new List<int>();
    }
     
    // Find the position of integer K
    int pos = 0;
  
    for(i = 0; i < n; i++)
    {
        if (arr[i] == K)
        {
            pos = i;
            break;
        }
    }
  
    // Insert the elements with their
    // distance from K in vector
    int j = pos + 1;
     i = pos - 1;
   
    // Element at distnce 0
    vd[0].Add(arr[pos]);
  
    // Elements at left side of K
    while (i >= 0)
    {
        vd[pos - i].Add(arr[i]);
        --i;
    }
  
    // Elements at right side of K
    while (j < n)
    {
        vd[j - pos].Add(arr[j]);
        ++j;
    }
  
    // Print the vector content in sorted order
    for(i = 0; i <= Math.Max(pos,
                             n - pos - 1); ++i)
    {       
        // Sort elements at same distance
        vd[i].Sort();
  
        // Print elements at distance i from K
        for (j = 0; j < vd[i].Count; j++)
        {
            int element = (int)vd[i][j];
            Console.Write(element + " ");
        }
    }
}
     
// Driver Code
public static void Main(String []args)
{
    int []arr = {14, 1101, 10, 35, 0};
    int K = 35;
    int n = arr.Length;
    distanceSort(arr, K, n);
}   
}
 
// This code is contributed by shikhasingrajput
Output: 
35 0 10 1101 14



 

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :