# 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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 CPP implementation of above approach :

```// CPP for printing smallest n number in order
#include <algorithm>
#include <iostream>
using namespace std;

// Function to print smallest n numbers
void 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 program
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;
}
```

Output :

```1 3 4 2 0
```

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).

This article is contributed by ma5ter6it. 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.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2 Average Difficulty : 2/5.0
Based on 1 vote(s)

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.