# n smallest element in an array

Finding the X smallest elements in an array is a common problem in computer science and data analysis. The algorithm for finding the X smallest elements in an array can be implemented in various ways, but we will explore two popular approaches: sorting and using a priority queue.

Approach 1: Sorting

One of the simplest approaches to finding the X smallest elements in an array is to sort the array in ascending order and then extract the first X elements. This approach has a time complexity of O(n log n) due to the sorting step.

Here is the algorithm in pseudocode:

1. Sort the array in ascending order.
2. Extract the first X elements from the sorted array.
3. Return the X smallest elements.

Let’s say we have an array [4, 2, 6, 8, 1, 3] and we want to find the 3 smallest elements. Using this algorithm, we would sort the array and extract the first 3 elements:

1. Sort the array: [1, 2, 3, 4, 6, 8]
2. Extract the first 3 elements: [1, 2, 3]
3. Return the 3 smallest elements: [1, 2, 3]

Approach 2: Priority Queue

Another approach to finding the X smallest elements in an array is to use a priority queue. A priority queue is a data structure that allows for efficient retrieval of the highest-priority element. In this case, we will use a min-heap priority queue to retrieve the X smallest elements.

Here is the algorithm in pseudocode:

1. Create a min-heap priority queue.
2. Add the first X elements from the array to the priority queue.
3. For each remaining element in the array: a. If the element is smaller than the highest-priority element in the priority queue: i. Remove the highest-priority element from the priority queue. ii. Add the new element to the priority queue.
4. Return the X smallest elements in the priority queue.

Let’s say we have the same array [4, 2, 6, 8, 1, 3] and we want to find the 3 smallest elements. Using this algorithm, we would create a min-heap priority queue and add the first 3 elements to it:

1. Create a min-heap priority queue: []
2. Add the first 3 elements to the priority queue: [4, 2, 6]
3. For each remaining element in the array: a. Check if the element is smaller than the highest-priority element in the priority queue. b. If the element is smaller, remove the highest-priority element from the priority queue and add the new element to the priority queue.
4. Return the 3 smallest elements in the priority queue: [1, 2, 3]

Using a priority queue can be more efficient than sorting the entire array, especially if we only need a small subset of the array. The time complexity of this algorithm is O(n log X) since we only need to add and remove X elements from the priority queue.