Print n smallest elements from given array in their original order
Last Updated :
27 Jul, 2022
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).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...