数组中第 K 大的元素

2024年8月28日 | 阅读 18 分钟

本文将教我们如何在未排序的数组中找到第 K 大的元素。有多种方法可以解决给定的问题。下面讨论了最佳实践。

问题 - 考虑一个包含 N 个元素的未排序数组。给定一个小于数组大小的数字 k；我们必须以最佳方式找到第 K 大的元素。

例如

K = 3
Input: A[] = {14, 5, 6, 12, 14, 8, 10, 6, 25}
Output: Kth largest element = 12

K = 5
Input: A[] = {18, 15, 3, 1, 2, 6, 2, 18, 16}
Output: Kth largest element = 3

方法 1： 最直接的方法是排序给定的数组并返回所需的值。我们可以使用堆排序或归并排序在 O(N Log N) 的时间内找到解决方案。

假设数组没有重复元素

在 C++ 中

// Program to find the kth largest element using the sorting method in C++
#include <iostream>
#include <bits/stdc++.h>
using namespace std;

// Function that returns the Kth largest element
int kth_largest_element(int arr[], int k, int n){
    // Sorts the array
    sort(arr, arr + n);

    // Reverses the array
    reverse(arr, arr+n);

    // Returns the required element
    return arr[k-1];
}

int main(){
    // Given array
    int arr[] = {12, 15, 7, 3, 8, 16, 25};

    // n represents the size of the array
    int n = sizeof(arr) / sizeof(arr[0]);

    int k = 3;
    cout << "The "<< k << "th largest element = " << kth_largest_element(arr, k, n) << endl;
    return 0;
}

示例输出

The 3th largest element = 15

在 C 语言中：

// Program to find the kth largest element using sorting method in C
#include <stdio.h>
#include <stdlib.h>

// Compare function for the qsort
int cmp_func (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

// Function that reverses the array
void reverse (int arr[], int n){
    for(int i = 0; i < n/2; i++){
        int temp = arr[i];
        arr[i] = arr[n-i-1];
        arr[n-i-1] = temp;
    }
}

// Function that returns the Kth largest element
int kth_largest_element(int arr[], int k, int n){
    // Sorts the array
    qsort(arr, n, sizeof(int), cmp_func);

    // Reverses the array
    reverse(arr, n);

    // Returns the required element
    return arr[k-1];
}

int main(){
    // Given array
    int arr[] = {12, 15, 7, 3, 8, 16, 25};
    
    // n represents the size of the array
    int n = sizeof(arr) / sizeof(arr[0]);

    int k = 4;
    printf("The %dth largest element = %d", k, kth_largest_element(arr, k, n));
    return 0;
}

示例输出

The 4th largest element = 12

在 Python 中

# Python program to find the Kth largest element
# Treating the given array as a python list
arr = [12, 15, 7, 3, 8, 16, 25]

# Function that returns the Kth largest value
def kth_largest_element(k):
    global arr

    # Sorts the function in reverse order
    arr.sort(reverse = True)

    # Returns the correct value
    return arr[k-1]

k = 5
print(f"The {k}th largest element = {kth_largest_element(k)}")

示例输出

The 5th largest element = 8

C++ 代码

#include <bits/stdc++.h>
using namespace std;

// Given array
int arr[] = {10, 12, 2, 54, 5, 18, 36, 22, 12, 4, 10};
// n = number of elements in the array 
int n = sizeof(arr) / sizeof(arr[0]);
// We have to find the kth largest value                
int k = 3;                                             

// Our set
set<int> mySet(arr, arr + n);
// Itr -> iterator for the set
set<int>::iterator itr;

// Function to calculate the length of the set
int len(int x)
{
    // The for loop starts from the starting of the set and ends at the end of the set
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        x++;
    }
    return x; // returns the length of the set to the main function
}

// Function to find the kth largest value
int find_kth(int k, int set_len)
{
    // The for loop starts from the starting of the set and ends at the end of the set
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        // When the set length becomes equal to the k means itr is pointing to the kth largest value
        if (set_len == k)
        {
            return *itr; // Returning the value to the main function
        }
        set_len--;
    }
}

// Funtion to display the set
void display_set()
{
    cout << "My set = {";
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        cout << *itr << ", ";
    }
    cout << "}" << endl;
}

int main()
{
    int set_len = 0;
    // Calling the set length to calculate the length of the set
    set_len = len(set_len);

    // Printing all the elements of the set
    display_set();

    // Calling the find_kth function to find the desired value
    int kth_largest_element = find_kth(k, set_len);

    // Printing the result in output
    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

示例输出

My set = {2, 4, 5, 10, 12, 18, 22, 36, 54}
The 3th largest element = 22

Python 代码

# Funtion to calculate the length of the set
def set_len():
    x = 0
    for item in myset:
        x += 1
    return x

# Funtion to find the kth largest value
def find_kth():
    global len_set
    global k
    for item in myset:
        if(len_set == k):
            print(f"The {k}th largest element = {item}")
        len_set -= 1

# Treating the given array as a python list
arr = [15, 17, 28, 26, 27, 12, 10, 8, 10, 12, 9, 22, 29]

# Typecasting the list into a set
myset = set(arr)
k = 5

# Calculating the length of the set using the set_len function
len_set = set_len()

# Printing the set
print(f"My set = {myset}")

# Finding the kth largest value by calling the find_kth
find_kth()

输出

My set = {8, 9, 10, 12, 15, 17, 22, 26, 27, 28, 29}
The 5th largest element = 22

方法 3 - 使用最大堆

可以使用堆找到第 K 大的元素。这里，我们使用了最大堆；我们首先将给定数组转换为最大堆，然后用最后一个元素替换根，将堆大小减一，然后再次将其转换为最大堆。我们重复相同的步骤 k-1 次。之后，在根索引 = 0 处找到第 K 个元素。

C++ 代码

C++ program to find the kth largest element in an array with the distinct element using heaps
#include <iostream>
using namespace std;

void max_heapify(int arr[], int n, int i)
{
    int largest = i;             // Initializing the parent index as the largest
    int left_child = 2 * i + 1;  // Formula to find the left child of i
    int right_child = 2 * i + 2; // Formula to find the right child of i

    // If the left child is present in the heap and greater than the largest
    if (left_child < n && arr[left_child] > arr[largest])
        largest = left_child; // If condition passes, then left child becomes the largest

    // If the right child is in the heap and greater than the largest
    if (right_child < n && arr[right_child] > arr[largest])
        largest = right_child; // If condition passes, then right child becomes the largest

    // If the largest is not the parent
    if (largest != i)
    {
        swap(arr[i], arr[largest]);
        max_heapify(arr, n, largest);
    }
}

// Function that converts the given array into a max heap
void build_max_heap(int arr[], int n)
{
    int start = (n / 2) - 1;

    for (int i = start; i >= 0; i--)
    {
        max_heapify(arr, n, i);
    }
}

// Function that returns the kth largest element
int find_kth(int arr[], int n, int k)
{
    // Converting the given array into a max - heap first
    build_max_heap(arr, n);
        // The below for loops selects the max and replaces the root element with the last element k-1 times
        for (int i = 0; i != k - 1; i++)
        {
            swap(arr[0], arr[n - i - 1]);
            n = n - 1;
            max_heapify(arr, n, 0);
        } // At the end of the loop, the kth element can be found at the root, i.e., at index = 0
    return arr[0];
}

// Main function
int main()
{
    int arr[] = {25, 16, 12, 5, 9, 3, 4, 7}; // Initializing the array
    int n = sizeof(arr) / sizeof(arr[0]);    // N -> number of element in arr
    int k = 2;                               // Initializing the value of k

    int kth_largest_element;
    kth_largest_element = find_kth(arr, n, k);

    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

输出

The 2th largest element = 16

C 代码

// C++ program to find the kth largest element in an array with distinct element using heaps
#include <stdio.h>

void swap(int *p, int *q){
    int temp = *p;
    *p = *q;
    *q = temp;
}

void max_heapify(int arr[], int n, int i)
{
    int largest = i;             // Initializing the parent index as the largest
    int left_child = 2 * i + 1;  // Formula to find the left child of i
    int right_child = 2 * i + 2; // Formula to find the right child of i

    // If the left child is present in the heap and greater than the largest
    if (left_child < n && arr[left_child] > arr[largest])
        largest = left_child; // If condition passes, then left child becomes the largest

    // If the right child is in the heap and greater than the largest
    if (right_child < n && arr[right_child] > arr[largest])
        largest = right_child; // If condition passes, then right child becomes the largest

    // If the largest is not the parent
    if (largest != i)
    {
        swap(&arr[i], &arr[largest]);
        max_heapify(arr, n, largest);
    }
}

// Function that converts the given array into a max heap
void build_max_heap(int arr[], int n)
{
    int start = (n / 2) - 1;

    for (int i = start; i >= 0; i--)
    {
        max_heapify(arr, n, i);
    }
}

// Function that returns the kth largest element
int find_kth(int arr[], int n, int k)
{
    // Converting the given array into a max - heap first
    build_max_heap(arr, n);
        // The below for loops selects the max and replaces the root element with the last element k-1 times
        for (int i = 0; i != k - 1; i++)
        {
            swap(&arr[0], &arr[n - i - 1]);
            n = n - 1;
            max_heapify(arr, n, 0);
        } // At the end of the loop, the kth element can be found at the root, i.e., at index = 0
    return arr[0];
}

// Main function
int main()
{
    int arr[] = {25, 16, 12, 5, 9, 3, 4, 7}; // Initializing the array
    int n = sizeof(arr) / sizeof(arr[0]);    // n -> number of element in arr
    int k = 4;                               // Initializing the value of k

    int kth_largest_element;
    kth_largest_element = find_kth(arr, n, k);

    printf("The %dth largest element = %d", k, kth_largest_element);

    return 0;
}

输出

The 3th largest element = 12

方法 4 - 使用最小堆

在此方法中，我们创建一个包含 k 个元素的最小堆，其最小值（根元素）将是第 K 大值。如果数组中有超过 k 个元素，那么我们检查每个元素是否大于堆的根元素，我们将对所有剩余元素执行以下步骤。

如果元素小于根，则意味着第 K 大值仍然是根元素，然后我们为下一个元素检查条件。
如果元素大于根，则意味着根元素不是第 K 大值，我们将根替换为该元素，并在根索引处调用 min-heapify。
执行结束时，我们将返回根元素，该元素将是第 K 大值。

此方法的 time complexity 为 T(n) = klogk + (n-k)logk

And the space complexity = O(k)

C++ 代码

// C++ program to find the kth largest value using a min-heap
#include <iostream>
using namespace std;

// Function to find the parent index of the child k
int parent(int k)
{
    return (k - 1) / 2;
}

// Function to find the left child index of parent k
int left_child(int k)
{
    return 2 * k + 1;
}

// Function to find the right child index of parent k
int right_child(int k)
{
    return 2 * k + 2;
}

// Function to convert the given array into a min heap
void min_heapify(int auxiliary_array[], int parent_index, int heap_size)
{
    // Finding the index value of left and right children
    int left_child_index = left_child(parent_index);
    int right_child_index = right_child(parent_index);

    // Assuming the parent is the smallest
    int smallest_index = parent_index;

    // If the left child is smaller than the parent
    if (left_child_index < heap_size && auxiliary_array[left_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = left_child_index;
    }

    // If the right child is smaller than the parent
    if (right_child_index < heap_size && auxiliary_array[right_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = right_child_index;
    }

    // If the smallest is not the parent
    if (smallest_index != parent_index)
    {
        // Swapping parent with the smallest child
        swap(auxiliary_array[smallest_index], auxiliary_array[parent_index]);
        // Calling min heapify for further improvement at the index of the smallest child
        min_heapify(auxiliary_array, smallest_index, heap_size);
    }
}

// Min - heap function
int min_heap(int arr[], int n, int k)
{
    // Creating an auxiliary array of size k
    int auxiliary_array[k];

    // Intializing the values of the main array into the auxiliary array
    for (int i = 0; i < k; i++)
    {
        auxiliary_array[i] = arr[i];
    }

    // Converting the auxiliary array into a min heap
    for (int i = (k - 1) / 2; i < 0; i--)
    {
        min_heapify(auxiliary_array, i, k);
    }

    // When there are more than k elements in the given array
    if (k < n)
    {
        // For loop runs for the heap size - k elements
        for (int i = k; i < n; i++)
        {
            // If the element is greater than the root elements of the auxiliary array
            if (arr[i] > auxiliary_array[0])
            {
                // Updating the root value
                auxiliary_array[0] = arr[i];

                // Converting the auillary array into a min heap again
                min_heapify(auxiliary_array, 0, k);
            }
        }
    }

    // Returning the root element of the auxiliary array
    return auxiliary_array[0];
}

// Main function
int main()
{
    // Initializing the array
    int arr[] = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33};

    // n -> number of elements in main array
    int n = sizeof(arr) / sizeof(arr[0]);

    // K -> would be the size of the min heap
    int k = 5;

    // Storing the kth largest value in a variable
    int kth_largest_value = min_heap(arr, n, k);

    // Printing the array
    cout << "My array = {";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << "}" << endl;

    // Printing the kth largest value
    cout << "The " << k << "th largest value = " << kth_largest_value << endl;
    return 0;
}

输出

My array = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33}
The 5th largest value = 17

C 代码

// C program to find the kth largest value using a min heap
#include <stdio.h>

// Function to find the parent index of the child k
int parent(int k)
{
    return (k - 1) / 2;
}

// Function to find the left child index of parent k
int left_child(int k)
{
    return 2 * k + 1;
}

// Function to find the right child index of parent k
int right_child(int k)
{
    return 2 * k + 2;
}

void swap(int *p, int *q)
{
    int temp = *p;
    *p = *q;
    *q = temp;
}

// Function to convert the given array into a min heap
void min_heapify(int auxiliary_array[], int parent_index, int heap_size)
{
    // Finding the index value of left and right children
    int left_child_index = left_child(parent_index);
    int right_child_index = right_child(parent_index);

    // Assuming the parent is the smallest
    int smallest_index = parent_index;

    // If the left child is smaller than the parent
    if (left_child_index < heap_size && auxiliary_array[left_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = left_child_index;
    }

    // If the right child is smaller than the parent
    if (right_child_index < heap_size && auxiliary_array[right_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = right_child_index;
    }

    // If the smallest is not the parent
    if (smallest_index != parent_index)
    {
        // Swapping parent with the smallest child
        swap(&auxiliary_array[smallest_index], &auxiliary_array[parent_index]);
        // Calling min heapify for further improvement at the index of the smallest child
        min_heapify(auxiliary_array, smallest_index, heap_size);
    }
}

// Min - heap function
int min_heap(int arr[], int n, int k)
{
    // Creating an auxiliary array of size k
    int auxiliary_array[k];

    // Initializing the values of the main array into the auxiliary array
    for (int i = 0; i < k; i++)
    {
        auxiliary_array[i] = arr[i];
    }

    // Converting the auxiliary array into a min heap
    for (int i = (k - 1) / 2; i < 0; i--)
    {
        min_heapify(auxiliary_array, i, k);
    }

    // When there are more than k elements in the given array
    if (k < n)
    {
        // For loop runs for the heap size - k elements
        for (int i = k; i < n; i++)
        {
            // If the element is greater than the root elements of the auxiliary array
            if (arr[i] > auxiliary_array[0])
            {
                // Updating the root value
                auxiliary_array[0] = arr[i];

                // Converting the auillary array into a min heap again
                min_heapify(auxiliary_array, 0, k);
            }
        }
    }

    // Returning the root element of the auxiliary array
    return auxiliary_array[0];
}

// Main function
int main()
{
    // Intializing the array
    int arr[] = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33};

    // n -> number of elements in main array
    int n = sizeof(arr) / sizeof(arr[0]);

    // K -> would be the size of the min heap
    int k = 4;

    // Storing the kth largest value in a variable
    int kth_largest_value = min_heap(arr, n, k);

    // Printing the array
    printf("My array = {");
    for (int i = 0; i < n; i++)
    {
        printf("%d, ", arr[i]);
    }
    printf("}\n");

    // Printing the kth largest value
    printf("The %dth largest value = %d", k, kth_largest_value);
    return 0;
}

输出

My array = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33, }
The 4th largest value = 23

方法 5 - 部分快速排序

在此方法中，我们利用快速排序的思想来查找数组中的第 K 大元素。我们知道，快速排序选择一个枢轴元素，将其放置在其正确的位置，然后递归地重复相同的过程，直到数组被排序。类似地，我们执行相同的步骤，但不是完全执行快速排序。当枢轴本身是第 K 大值时，我们将停止执行并打印所需值。此方法的 worst time complexity 为 O(n^2)，average time complexity 为 O(N logN)。我们在比平均情况复杂度更短的时间内实现了所需的输出。

C++ 代码

// C++ program to find the kth largest value using partial quick sort
// The below code is the modified quick sort in reverse order
#include <iostream>
using namespace std;

// Function to swap two values using pointers
void swap(int *p, int *j)
{
    int temp = *p;
    *p = *j;
    *j = temp;
}

// Partition function
int partition(int arr[], int first, int last)
{
    // Selects the last element as the pivot
    int pivot_element = arr[last];

    int i = first - 1;

    for (int j = first; j < last; j++)
    {
        // If the pivot is smaller than the pivot. It increases the value of i and swaps the elements at indices i and j
        if (arr[j] > pivot_element)
        {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    // Places the pivot element at its correct position
    swap(&arr[i + 1], &arr[last]);

    // Returns the index of the pivot element
    return i + 1;
}

// Quick sort function
int quicksort(int arr[], int first, int last, int k)
{
    // If the array has at least two elements in it
    if (first < last)
    {
        // Pi -> stores the index of the pivot
        int pi = partition(arr, first, last);

        // When pi points to the kth largest value
        if (pi == k - 1)
        {
            return arr[k - 1];
        }

        // If the kth largest value is smaller than the pivot
        else if (pi < k)
        {
            quicksort(arr, pi + 1, last, k);
        }

        // If the kth largest value is greater than the pivot
        else
        {
            quicksort(arr, first, pi - 1, k);
        }
    }
    // Returns the kth largest value
    return arr[k - 1];
}

// Main function
int main()
{
    int arr[] = {12, 45, 66, 13, 85, 14, 69, 25, 33, 18};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 5;

    // Variable to store the kth largest value
    int kth_largest_element;
    kth_largest_element = quicksort(arr, 0, n - 1, k);

    // Printing the array
    cout << "The array = [";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << "]" << endl;

    // Printing the desired output
    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

输出

The array = [45, 66, 85, 69, 33, 25, 18, 12, 14, 13]
The 5th largest element = 33

C 代码

// C program to find the kth largest value using partial quick sort
// The below code is the modified quick sort in reverse order
#include <stdio.h>

// Function to swap two values using pointers
void swap(int *p, int *j)
{
    int temp = *p;
    *p = *j;
    *j = temp;
}

// Partition function
int partition(int arr[], int first, int last)
{
    // Selects the last element as the pivot
    int pivot_element = arr[last];

    int i = first - 1;

    for (int j = first; j < last; j++)
    {
        // If the pivot is smaller than the pivot. It increases the value of i and swaps the elements at indices i and j
        if (arr[j] > pivot_element)
        {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    // Places the pivot element at its correct position
    swap(&arr[i + 1], &arr[last]);

    // Returns the index of the pivot element
    return i + 1;
}

// Quick sort function
int quicksort(int arr[], int first, int last, int k)
{
    // If the array has at least two elements in it
    if (first < last)
    {
        // Pi -> stores the index of the pivot
        int pi = partition(arr, first, last);

        // When pi points to the kth largest value
        if (pi == k - 1)
        {
            return arr[k - 1];
        }

        // If the kth largest value is smaller than the pivot
        else if (pi < k)
        {
            quicksort(arr, pi + 1, last, k);
        }

        // If the kth largest value is greater than the pivot
        else
        {
            quicksort(arr, first, pi - 1, k);
        }
    }
    // Returns the kth largest value
    return arr[k - 1];
}

// Main function
int main()
{
    int arr[] = {11, 35, 60, 18, 75, 85, 69, 28, 37, 26};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;

    // Variable to store the kth largest value
    int kth_largest_element;
    kth_largest_element = quicksort(arr, 0, n - 1, k);

    // Printing the array
    printf("The array = [");
    for (int i = 0; i < n; i++)
    {
        printf("%d, ", arr[i]);
    }
    printf("]\n");

    // Printing the desired output
    printf("The %dth largest element = %d\n", k, kth_largest_element);

    return 0;
}

输出

The array = [75, 85, 69, 60, 37, 28, 35, 26, 11, 18]
The 4th largest element = 60

# Python program to find the kth largest value in the array using the quick sort partially.
# In this program, we have used the quick sort algorithm to sort the array in reverse order.
# At any stage, when the pivot element itself becomes the kth largest value, we stop the execution
# of the program and return the value.

# Partition function of the quick sort
def partition(array, first, last):
    # Last element as the pivot
    pivot = array[last]
    i = first - 1
    
    # For loop runs from first to last - 1
    for j in range(first, last):
        # If the element is greater than the pivot
        if array[j] > pivot:
            i += 1
            # Swapping method in python
            array[j], array[i] = array[i], array[j]

    # Swapping the pivot element with the element at index = i+1
    array[i+1], array[last] = array[last], array[i+1]

    # Returning the index of the pivot
    return i + 1

def quicksort(array, first, last, k):
    # If the array has at least two elements
    if first < last:
        # Calling the partition function with the 0 and 9 index values
        # and storing the index of the pivot in pi
        pi = partition(array, first, last)

        # when pi is equal to the k-1 means the pivot is itself the kth largest value
        if pi == k-1:
            return array[k-1]

        # When the kth largest value is at the right side of the pivot
        elif pi < k:
            quicksort(array, pi+1, last, k)

        #When the kth largest value is at the left side of the pivot
        else:
            quicksort(array, first, pi-1, k)

    # Returning the kth largest value   
    return array[k-1]

# Treating the given array as the python list
My_array = [41, 15, 11, 32, 14, 12, 20, 25, 33, 78]
k = 6

# Storing the kth largest element in the below variable
kth_largest_element = quicksort(My_array, 0, len(My_array)-1, k)

# Printing the result
print(f"My array = {My_array}")
print(f"The {k}th largest element = {kth_largest_element}")

输出

My array = [78, 41, 33, 32, 25, 20, 15, 14, 12, 11]
The 6th largest element = 20

下一个主题排序几乎有序、k-有序或近乎有序的数组

← 上一个下一个 →

数组中第 K 大的元素

在 C++ 中

在 C 语言中：

在 Python 中

C++ 代码

Python 代码

方法 3 - 使用最大堆

C++ 代码

C 代码

方法 4 - 使用最小堆

C++ 代码

C 代码

方法 5 - 部分快速排序

C++ 代码

C 代码

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

数组中第 K 大的元素

在 C++ 中

在 C 语言中：

在 Python 中

C++ 代码

Python 代码

方法 3 - 使用最大堆

C++ 代码

C 代码

方法 4 - 使用最小堆

C++ 代码

C 代码

方法 5 - 部分快速排序

C++ 代码

C 代码

相关帖子

递归冒泡排序

回文树

使用相同数字集查找下一个回文数

克隆带有随机指针的二叉树

Ackermann 函数

不使用递归进行中序遍历

根据另一个字符串定义的字母顺序对字符串数组进行排序

完美二叉树

使用最小堆合并 K 个排序链表

股票收益问题

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器