Print n smallest elements from given array in their original order
We are given an array of m-elements, we need to find n smallest elements from the array but they must be in the same order as they are in given array.
Examples:
Input : arr[] = {4, 2, 6, 1, 5},
n = 3
Output : 4 2 1
Explanation :
1, 2 and 4 are 3 smallest numbers and
4 2 1 is their order in given array.
Input : arr[] = {4, 12, 16, 21, 25},
n = 3
Output : 4 12 16
Explanation :
4, 12 and 16 are 3 smallest numbers and
4 12 16 is their order in given array.
Make a copy of original array and then sort copy array. After sorting the copy array, save all n smallest numbers. Further for each element in original array, check whether it is in n-smallest number or not if it present in n-smallest array then print it otherwise move forward.
Make copy_arr[]sort(copy_arr)For all elements in arr[] – Find arr[i] in n-smallest element of copy_arr If found then print the element
Below is the implementation of above approach :
C++
#include <bits/stdc++.h>
using namespace std;
void printSmall( int arr[], int asize, int n)
{
vector< int > copy_arr(arr, arr + asize);
sort(copy_arr.begin(), copy_arr.begin() + asize);
for ( int i = 0; i < asize; ++i)
if (binary_search(copy_arr.begin(),
copy_arr.begin() + n, arr[i]))
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int asize = sizeof (arr) / sizeof (arr[0]);
int n = 5;
printSmall(arr, asize, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static void printSmall( int arr[], int asize, int n)
{
int []copy_arr = Arrays.copyOf(arr,asize);
Arrays.sort(copy_arr);
for ( int i = 0 ; i < asize; ++i)
{
if (Arrays.binarySearch(copy_arr, 0 ,n, arr[i])>- 1 )
System.out.print(arr[i] + " " );
}
}
public static void main(String[] args)
{
int arr[] = { 1 , 5 , 8 , 9 , 6 , 7 , 3 , 4 , 2 , 0 };
int asize = arr.length;
int n = 5 ;
printSmall(arr, asize, n);
}
}
|
Python3
def binary_search(arr, low, high, ele):
while low < high:
mid = (low + high) / / 2
if arr[mid] = = ele:
return mid
elif arr[mid] > ele:
high = mid
else :
low = mid + 1
return - 1
def printSmall(arr, asize, n):
copy_arr = arr.copy()
copy_arr.sort()
for i in range (asize):
if binary_search(copy_arr, low = 0 ,
high = n, ele = arr[i]) > - 1 :
print (arr[i], end = " " )
if __name__ = = "__main__" :
arr = [ 1 , 5 , 8 , 9 , 6 , 7 , 3 , 4 , 2 , 0 ]
asize = len (arr)
n = 5
printSmall(arr, asize, n)
|
C#
using System;
class GFG
{
static void printSmall( int []arr, int asize, int n)
{
int []copy_arr = new int [asize];
Array.Copy(arr, copy_arr, asize);
Array.Sort(copy_arr);
for ( int i = 0; i < asize; ++i)
{
if (Array.BinarySearch(copy_arr, 0, n, arr[i])>-1)
Console.Write(arr[i] + " " );
}
}
public static void Main(String[] args)
{
int []arr = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int asize = arr.Length;
int n = 5;
printSmall(arr, asize, n);
}
}
|
Javascript
<script>
function printSmall(arr, asize, n)
{
let copy_arr = [...arr];
copy_arr.sort((a, b) => a - b);
for (let i = 0; i < asize; ++i) {
if (arr[i] < copy_arr[n])
document.write(arr[i] + " " );
}
}
let arr = [1, 5, 8, 9, 6, 7, 3, 4, 2, 0];
let asize = arr.length;
let n = 5;
printSmall(arr, asize, n);
</script>
|
Time Complexity: O(n * log(n))
Auxiliary Space: O(n)
For making a copy of array we need space complexity of O(n) and then for sorting we will need complexity of order O(n log n). Further for each element in arr[] we are performing searching in copy_arr[], which will result O(n) for linear search but we can improve it by applying binary search and hence our overall time complexity will be O(n log n).
Last Updated :
27 Jul, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...