C# 第k个最小元素(K’th Smallest Element)

[【朴素方法】使用排序------时间复杂度为 O(n log(n))，空间复杂度为 O(1)](#【朴素方法】使用排序——时间复杂度为 O(n log(n))，空间复杂度为 O(1))

[【预期方法】使用最大堆 - 时间复杂度为 O(n * log(k))，空间复杂度为 O(k)](#【预期方法】使用最大堆 - 时间复杂度为 O(n * log(k))，空间复杂度为 O(k))

[【替代方案 1】使用快速选择](#【替代方案 1】使用快速选择)

[【替代方案 2】使用计数排序](#【替代方案 2】使用计数排序)

如果您喜欢此文章，请收藏、点赞、评论，谢谢，祝您快乐每一天。

给定一个整数数组arr\[\]和元素个数k，求数组中第 k 小的元素。

注意： k 始终小于数组的大小。

例如：

输入：arr\[\] = $10, 5, 4, 3, 48, 6, 2, 33, 53, 10$ , k = 4

输出：5

说明：给定数组中第四小的元素是 5。

输入：arr\[\] = $7, 10, 4, 3, 20, 15$ , k = 3

输出：7

说明：给定数组中第三小的元素是 7。

【朴素方法】使用排序------时间复杂度为 O(n log(n))，空间复杂度为 O(1)

其思路是对给定的数组进行排序，并返回索引 k - 1 处的元素。

using System;

class GFG

{

static int kthSmallest(int\[\] arr, int k)

{

// Sort the given array

Array.Sort(arr);

// Return k'th element in the sorted array

return arr $k - 1$ ;

}

static void Main()

{

int\[\] arr = {10, 5, 4, 3, 48, 6, 2, 33, 53, 10};

int k = 4;

Console.WriteLine(kthSmallest(arr, k));

}

输出

【预期方法】使用最大堆 - 时间复杂度为 O(n * log(k))，空间复杂度为 O(k)

其思路是在遍历数组的过程中维护一个大小为 k 的最大堆。该堆始终包含目前为止遇到的 k 个最小元素。如果堆的大小超过 k，则移除最大的元素。最终，堆中只保留 k 个最小元素。

using System;

class MaxHeap

{

private int\[\] heap;

private int size;

public MaxHeap(int capacity)

{

heap = new int $capacity$ ;

size = 0;

}

public int Count => size;

public void Push(int val)

{

heap $size$ = val;

int i = size;

size++;

while (i > 0)

{

int parent = (i - 1) / 2;

if (heap $parent$ >= heap $i$ )

break;

int temp = heap $parent$ ;

heap $parent$ = heap $i$ ;

heap $i$ = temp;

i = parent;

}

public int Pop()

{

if (size == 0)

{

Console.WriteLine("Heap is empty");

return -1;

}

int top = heap $0$ ;

heap $0$ = heap $size - 1$ ;

size--;

int i = 0;

while (true)

{

int left = 2 * i + 1;

int right = 2 * i + 2;

int largest = i;

if (left < size && heap $left$ > heap $largest$ )

largest = left;

if (right < size && heap $right$ > heap $largest$ )

largest = right;

if (largest == i)

break;

int temp = heap $i$ ;

heap $i$ = heap $largest$ ;

heap $largest$ = temp;

i = largest;

}

return top;

}

public int Top()

{

if (size == 0)

{

Console.WriteLine("Heap is empty");

return -1;

}

return heap $0$ ;

}

class GFG {

static int kthSmallest(int\[\] arr, int k)

{

// Create a max heap

MaxHeap pq = new MaxHeap(arr.Length);

// Iterate through the array elements

for (int i = 0; i < arr.Length; i++)

{

// Push the current element onto the max heap

pq.Push(arr $i$ );

// If the size of the max heap exceeds k,

//remove the largest element

if (pq.Count > k)

pq.Pop();

}

// Return the kth smallest element (top of the max heap)

return pq.Top();

}

static void Main()

{

int\[\] arr = {10, 5, 4, 3, 48, 6, 2, 33, 53, 10};

int k = 4;

Console.WriteLine(kthSmallest(arr, k));

}

输出

【替代方案 1】使用快速选择

主要思路是利用快速选择（QuickSelect）函数找到第 k 大元素。具体做法是：选择一个基准元素，然后将数组分割成多个部分，使得大于基准元素的元素位于左侧，小于基准元素的元素位于右侧。如果基准元素最终位于索引 k-1 处，则该元素即为第 k 大元素。否则，我们递归地仅在包含第 k 大元素的左侧或右侧部分进行搜索。

using System;

class GFG {

static int partition(int\[\] arr, int left, int right) {

// Choose the last element as pivot

int pivot = arr $right$ ;

int i = left;

// Traverse the array and move elements <= pivot to the left

for (int j = left; j < right; j++) {

if (arr $j$ <= pivot) {

// Swap current element with element at i

int temp = arr $i$ ;

arr $i$ = arr $j$ ;

arr $j$ = temp;

i++;

}

// Place the pivot in its correct position

int tempPivot = arr $i$ ;

arr $i$ = arr $right$ ;

arr $right$ = tempPivot;

return i;

}

static int quickSelect(int\[\] arr, int left, int right, int k) {

if (left <= right) {

// Partition around pivot

int pivotIndex = partition(arr, left, right);

// Found k-th smallest

if (pivotIndex == k)

return arr $pivotIndex$ ;

else if (pivotIndex > k)

return quickSelect(arr, left, pivotIndex - 1, k);

else

return quickSelect(arr, pivotIndex + 1, right, k);

}

return -1;

}

static int kthSmallest(int\[\] arr, int k) {

return quickSelect(arr, 0, arr.Length - 1, k - 1);

}

static void Main() {

int\[\] arr = {10, 5, 4, 3, 48, 6, 2, 33, 53, 10};

int k = 4;

Console.WriteLine(kthSmallest(arr, k));

}

输出

时间复杂度：最坏情况下为O(n² )，但平均时间为 O(n log n)，且性能优于基于优先级队列的算法。

辅助空间：最坏情况下递归调用栈为 O(n)。平均而言：O(log n)。

【替代方案 2】使用计数排序

主要思路是利用计数排序的频率计数来跟踪有多少元素小于或等于每个值，然后直接从这些累积计数中识别出第 K 小的元素，而无需对数组进行完全排序。

注意：这种方法在元素范围较小时特别有效，因为我们声明的数组大小为最大元素个数。如果元素范围非常大，计数排序方法可能并非最有效的选择。

using System;

class GFG {

static int kthSmallest(int\[\] arr, int k)

{

// First, find the maximum element in the array

int maxElement = arr $0$ ;

for (int i = 1; i < arr.Length; i++)

{

if (arr $i$ > maxElement)

maxElement = arr $i$ ;

}

// Create a frequency array for each element

int\[\] freq = new int $maxElement + 1$ ;

for (int i = 0; i < arr.Length; i++)

freq $arr\[i$ ]++;

// Keep track of cumulative frequency to find k-th smallest

int count = 0;

for (int i = 0; i <= maxElement; i++)

{

if (freq $i$ != 0)

{

count += freq $i$ ;

if (count >= k)

{

// If we have seen k or more elements,

// return the current element

return i;

}

return -1;

}

static void Main()

{

int\[\] arr = {10, 5, 4, 3, 48, 6, 2, 33, 53, 10};

int k = 4;

Console.WriteLine(kthSmallest(arr, k));

}

输出

时间复杂度： O(n + maxElement)，其中 maxElement 为数组中的最大元素。

辅助空间： O(maxElement)。

如果您喜欢此文章，请收藏、点赞、评论，谢谢，祝您快乐每一天。