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++
- Java
- Python3
- C#
- Javascript
C++
// CPP for printing smallest n number in order#include <bits/stdc++.h>using namespace std;// Function to print smallest n numbersvoid printSmall(int arr[], int asize, int n){ // Make copy of array vector<int> copy_arr(arr, arr + asize); // Sort copy array sort(copy_arr.begin(), copy_arr.begin() + asize); // For each arr[i] find whether // it is a part of n-smallest // with binary search for (int i = 0; i < asize; ++i) if (binary_search(copy_arr.begin(), copy_arr.begin() + n, arr[i])) cout << arr[i] << " ";}// Driver programint 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
Python3
C#
Javascript
1 3 4 2 0
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).
