最坏情况为线性时间的第k大元素

已于 2024-04-12 10:56:15 修改
阅读量940 收藏 14
点赞数 9
分类专栏： 算法 文章标签： 算法 数据结构 c语言
于 2024-04-10 21:42:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_40395808/article/details/137073643
版权

在统计和数据分析中，我们经常会遇到求最大值、最小值、中位数、四分位数、Top K等类似需求，其实它们都属于顺序统计量，本文将对顺序统计量的定义和求解算法进行介绍，重点介绍如何在最差时间复杂度也是线性的情况下求解第k大元素。

1. 顺序统计量与选择问题

在一个有 n n n个元素的集合中，第 i i i个顺序统计量是该集合中第 i i i小的元素。例如在集合 ( 1 , 3 , 5 , 2 ) (1, 3, 5, 2) (1,3,5,2)中，第2个顺序统计量为2。

从一个有 n n n个元素的集合中，选择出（求解）其第 i i i个顺序统计量的问题被称为选择问题。选择问题的输入输出如下：

输入：一个包含 n n n个不同的数的集合 A A A和一个数 i i i（ 1 ≤ i ≤ n 1 \leq i \leq n 1≤i≤n）；
输出：元素 x ∈ A x \in A x∈A，它恰大于A中其它 ( i − 1 ) (i-1) (i−1)个元素。

2. 选择问题的求解方法

显然，对输入集合 A A A进行排序之后就可以解决选择问题，使用堆排序或归并排序对输入集合进行排序，然后在排序后的数组中标出第 i i i个元素，即可在 O ( n log ⁡ n ) O(n\log{n}) O(nlogn)时间内完成求解，但还有更快的算法。

2.1 最大值与最小值

我们先考虑选择问题的特殊情况，只求解最大值或最小值，可以发现很容易在 O ( n ) O(n) O(n)时间内完成求解。只需要遍历数组，进行(n-1)次比较即可。以求解最小值为例，伪码如下：

MINIMUM(A)
min = A[1]
n = length[A]
for(i=2; i<=n; i++)
	if(min > A[i])
		min = A[i]
return min

在此基础上，增加一点难度，我们希望同时找最大值和最小值，是否还可以在 O ( n ) O(n) O(n)时间内完成求解呢？答案是肯定的，在遍历过程中不再每次比较一个元素，而是每次比较两个元素，两个元素中较小的元素与当前最小值比较，较大的元素和当前最大值比较，即每对元素需要3次比较即可。伪码如下：

MAX-MINIMUM(A)
if(length[A] is odd)
	min = A[1]
	max = min
else 
	min = MIN(A[1], A[2])
	max = MAX(A[1], A[2])
i++
while(i <= length[A])
	min = MIN(MIN(A[i], A[i+1]), min)
	max = MAX(MAX(A[i], A[i+1]), max)
	i = i + 2 
return min, max

在当前最大值和最小值初始值的设定上，如果n是奇数，将最大值和最小值均设置为第一个元素的值；如果n是偶数，就对前两个元素做一次比较来决定最大值与最小值的初始值。因此，如果n是奇数，那么总共做了 3 ⌊ n / 2 ⌋ 3\lfloor n/2 \rfloor 3⌊n/2⌋次比较；如果n是偶数，那么总共做了 3 n / 2 − 2 3n/2-2 3n/2−2次比较，时间复杂度为 O ( n ) O(n) O(n)。

2.2 期望时间为线性的选择问题

我们回到一般的选择问题，看起来一般的选择问题比求最小值和最大值复杂得多，但神奇的算法仍然可以让我们在平均为线性的时间完成求解。这里再次使用了分治思想，借鉴了快速排序的随机划分方法，如果刚好划分元的左边有(i-1)个元素，则找到第i小的元素；否则，在划分元的左侧或右侧继续进行随机划分。伪码如下：

RANDOMIZED-SELECT(A, p, r, i) // A为数组，p为数组左边界，r为数组右边界，i为待求的顺序统计量序号
if(p == r) // 临界问题处理
	return A[p]
q = RANDOMIZED-PARTITION(A, p, r) //进行划分，返回划分元下标
k = q – p + 1 // k=rank(A[q]) in A[p,…,r], 返回划分元的序号
if(i == k)
	return A[q]
else if(i < k)
	return RANDOMIZED-SELECT(A, p, q - 1, i)
else
	return RANDOMIZED-SELECT(A, q + 1, r, i – k)

可以证明在平均情况下，算法的时间复杂度为 O ( n ) O(n) O(n)。而当运气不好时，每次都只能去除一个元素，算法的时间复杂度就可能达到 O ( n 2 ) O(n^2) O(n2)。

2.3 最差时间为线性的选择问题

在上述RANDOMIZED-SELECT算法的基础上，保证每次对数组的划分是个好划分，我们就能进一步在最差情况下也用线性时间解决选择问题。主要步骤如下：

  1. 将n个元素每5个分为一组，一共 ⌈ n / 5 ⌉ \lceil n/5 \rceil ⌈n/5⌉组。最后一组有n mod 5个元素。
  2. 对每组进行排序，取其中位数。若最后一组有偶数个元素，则取较小的中位数。
  3. 递归地使用本算法寻找 ⌈ n / 5 ⌉ \lceil n/5 \rceil ⌈n/5⌉个中位数的中位数x。
  4. 用x作为划分元对数组A进行划分，并设x是第k个最小元。
  5. 如果i = k，则返回x；否则如果i < k，则找左区间的第i个最小元；如果i > k，则找右区间的第i - k个最小元。

伪码如下：

SELECT(A, p, r, i)
if(r - p <= 140)
	用简单的排序算法对数组A[p..r进行排序
	return A[p + k - 1]
n = r - p + 1
for(i = 0; i <= floor(n/5); i++) //寻找每组的中位数
	将A[p+5*i]至A[p+5*i+4]的第3小元素与A[p+i]交换位置
x = SELECT(A, p, p+floor(n/5), floor(n/10)) //找中位数的中位数
i = PARTITION(A, p, r, x)
j = i - p + 1
if(k <= j)
	return SELECT(A, p, i, k)
else 
	return SELECT(A, i + 1, r, k - j)

3. 程序代码

以下C语言程序代码实现了最坏情况为线性的select算法，将“求数组a[1..n]中第k大的元素”转化为“求数组a[1..n]中第(n-k+1)小的元素”。递归调用select时，设置数组长度不大于140时，即直接使用插入排序。

3.1 linearSelect_kth.cpp

#include <stdio.h>
#include <stdlib.h>

#define N 1000000     //定义输入数组的最大长度 
#define LEN 5         //定义select中每组元素的个数 

int a[N];

void swap(int *a, int *b) { //交换 a 与 b 的值 
	int tmp = *a;
    *a = *b;
    *b = tmp;
}

int partition(int a[], int low, int high, int pivot) { //将数组a[low..high]划分为 <= pivot和 > pivot的两部分 
    int x;
    int i = low - 1;
    int j;
    for (j = low; j < high; j++) { //在数组中找到值等于privot的元素作为主元，交换到数组最右端 
        if (a[j] == pivot) {
            swap(&a[j], &a[high]);
        }
    }
    x = a[high];
    for (j = low; j < high; j++) { //维护低区a[low..i] <= x, 高区a[i+1..j-1] > x  
        if (a[j] <= x) {           //如果发现a[j] <= x，则将a[j]交换到低区 
            i++;
            swap(&a[i], &a[j]);
        }
    }
    swap(&a[i + 1], &a[high]);    //将主元与最左的大于 x 的元素a[i+1]交换，此时主元到了它应在的位置 
    return i + 1;                 //返回分区完成后主元所在的新下标 
}

void insertSort(int a[], int low, int high) { //对a[low..high]进行插入排序 
    int i, j;
    for (i = low + 1; i <= high; i++) {
        int temp = a[i];
        for (j = i - 1; j >= low && temp < a[j]; j--) {
            a[j + 1] = a[j];
        }
        a[j + 1] = temp;
    }
}

int select(int a[], int begin, int end, int k) { //选出数组a[begin..end]的第k小元素 
    int length = end - begin + 1;   //数组长度，即数组中元素的个数 
    if (length <= 140) {            //长度较小，直接用插入排序 
        insertSort(a, begin, end);
        return a[begin + k - 1];
    }
    int groups = (length + LEN) / LEN;  //组数 
    int i;
    for (i = 0; i < groups; i++) {
        int left = begin + LEN * i;  //第i组的左边界 
        int right = (begin + LEN * i + LEN - 1) > end ? end : (begin + LEN * i + LEN - 1);  //第i组的右边界 
        insertSort(a, left, right);  //组内进行插入排序 
        //将第i组中位数与数组a[]的第i个元素互换位置，方便递归select寻找中位数的中位数
        int mid = (left + right) / 2;
        swap(&a[begin + i], &a[mid]); 
    }
    int pivot = select(a, begin, begin + groups - 1, (groups + 1) / 2);  //找出中位数的中位数
    int p = partition(a, begin, end, pivot);  //用中位数的中位数作为划分的主元
	int leftNum =  p - begin;                 //低区元素的数量 
    if (k == leftNum + 1) {
    	return a[p];
	}
    else if (k <= leftNum) {
    	return select(a, begin, p - 1, k);  //在低区递归调用select来找出第k小的元素 
	}
    else {
    	return select(a, p + 1, end, k - leftNum -1);  //在高区递归调用select来找出第(k-leftNum-1)小的元素 
	}   
}


int main() {
    FILE *fp = fopen("data_1022.txt","r");            //打开文件 
	if (fp == NULL) {
		printf("Can not open the file!\n");
		exit(0);
	}
	int i = 0;
	while (fscanf(fp, "%d\n", &a[i]) != EOF) {  //读取文件中的数据到数组a[]中 
		i++;
	}
	fclose(fp);                                 //关闭文件 
	int k;
	while (1) {
		printf("Please enter an integer k, and you will get the k-th largest element in the array!\n");
		printf("(Enter negative or zero to quit): ");
		scanf("%d", &k);
		if (k <= 0) {
			printf("Bye\n"); 
			break;
		}
    	printf("The %dth largest element in the array is: %d\n", k, select(a, 0, i - 1, i - k + 1));
    	printf("\n==================================================================================\n");
	}
    return 0;
}

3.2 linearSelect_kth_grouplenth_5_vs_7_vs_3.cpp

然后，在3.1节代码的基础上，我尝试改变每组元素的个数，分别设置每组元素个数为5、7、3，比较算法运行时间的差异。

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#define N 1000000     //定义输入数组的最大长度 
#define LEN1 5        //尝试改变select中每组元素的个数
#define LEN2 7
#define LEN3 3

int a[N];

void swap(int *a, int *b) { //交换 a 与 b 的值 
	int tmp = *a;
    *a = *b;
    *b = tmp;
}

int partition(int a[], int low, int high, int pivot) { //将数组a[low..high]划分为 <= pivot和 > pivot的两部分 
    int x;
    int i = low - 1;
    int j;
    for (j = low; j < high; j++) { //在数组中找到值等于privot的元素作为主元，交换到数组最右端 
        if (a[j] == pivot) {
            swap(&a[j], &a[high]);
        }
    }
    x = a[high];
    for (j = low; j < high; j++) { //维护低区a[low..i] <= x, 高区a[i+1..j-1] > x  
        if (a[j] <= x) {           //如果发现a[j] <= x，则将a[j]交换到低区 
            i++;
            swap(&a[i], &a[j]);
        }
    }
    swap(&a[i + 1], &a[high]);    //将主元与最左的大于 x 的元素a[i+1]交换，此时主元到了它应在的位置 
    return i + 1;                 //返回分区完成后主元所在的新下标 
}

void insertSort(int a[], int low, int high) { //对a[low..high]进行插入排序 
    int i, j;
    for (i = low + 1; i <= high; i++) {
        int temp = a[i];
        for (j = i - 1; j >= low && temp < a[j]; j--) {
            a[j + 1] = a[j];
        }
        a[j + 1] = temp;
    }
}

int select_5(int a[], int begin, int end, int k) { //选出数组a[begin..end]的第k小元素，分组长度为5 
    int length = end - begin + 1;  //数组长度，即数组中元素的个数
    if (length <= 140) {           //长度较小，直接用插入排序 
        insertSort(a, begin, end);
        return a[begin + k - 1];
    }
    int groups = (length + LEN1) / LEN1;  //组数
    int i;
    for (i = 0; i < groups; i++) {
        int left = begin + LEN1 * i;  //第i组的左边界 
        int right = (begin + LEN1 * i + LEN1 - 1) > end ? end : (begin + LEN1 * i + LEN1 - 1);  //第i组的右边界 
        insertSort(a, left, right);  //组内进行插入排序 
        //将第i组中位数与数组a[]的第i个元素互换位置，方便递归select寻找中位数的中位数
        int mid = (left + right) / 2;
        swap(&a[begin + i], &a[mid]); 
    }
    int pivot = select_5(a, begin, begin + groups - 1, (groups + 1) / 2);  //找出中位数的中位数
    int p = partition(a, begin, end, pivot);  //用中位数的中位数作为划分的主元
    int leftNum =  p - begin;                 //低区元素的数量 
    if (k == leftNum + 1) {
    	return a[p];
	}
    else if (k <= leftNum) {
    	return select_5(a, begin, p - 1, k);  //在低区递归调用select来找出第k小的元素 
	}
    else {
    	return select_5(a, p + 1, end, k - leftNum -1);  //在高区递归调用select来找出第(k-leftNum-1)小的元素 
	}   
}

int select_7(int a[], int begin, int end, int k) {
    int length = end - begin + 1;
    if (length <= 140) {
        insertSort(a, begin, end);
        return a[begin + k - 1];
    }
    int groups = (length + LEN2) / LEN2;
    int i;
    for (i = 0; i < groups; i++) {
        int left = begin + LEN2 * i;  //第i组的左边界 
        int right = (begin + LEN2 * i + LEN2 - 1) > end ? end : (begin + LEN2 * i + LEN2 - 1);  //第i组的右边界 
        insertSort(a, left, right);  //组内进行插入排序 
        //将第i组中位数与数组a[]的第i个元素互换位置，方便递归select寻找中位数的中位数
        int mid = (left + right) / 2;
        swap(&a[begin + i], &a[mid]); 
    }
    int pivot = select_7(a, begin, begin + groups - 1, (groups + 1) / 2);  //找出中位数的中位数
    int p = partition(a, begin, end, pivot);  //用中位数的中位数作为划分的主元
    int leftNum =  p - begin;                 //低区元素的数量 
    if (k == leftNum + 1) {
    	return a[p];
	}
    else if (k <= leftNum) {
    	return select_7(a, begin, p - 1, k);  //在低区递归调用select来找出第k小的元素 
	}
    else {
    	return select_7(a, p + 1, end, k - leftNum -1);  //在高区递归调用select来找出第(k-leftNum-1)小的元素 
	}   
}

int select_3(int a[], int begin, int end, int k) {
    int length = end - begin + 1;
    if (length <= 140) {
        insertSort(a, begin, end);
        return a[begin + k - 1];
    }
    int groups = (length + LEN3) / LEN3;
    int i;
    for (i = 0; i < groups; i++) {
        int left = begin + LEN3 * i;  //第i组的左边界 
        int right = (begin + LEN3 * i + LEN3 - 1) > end ? end : (begin + LEN3 * i + LEN3 - 1);  //第i组的右边界 
        insertSort(a, left, right);  //组内进行插入排序 
        //将第i组中位数与数组a[]的第i个元素互换位置，方便递归select寻找中位数的中位数
        int mid = (left + right) / 2;
        swap(&a[begin + i], &a[mid]); 
    }
    int pivot = select_3(a, begin, begin + groups - 1, (groups + 1) / 2);  //找出中位数的中位数
    int p = partition(a, begin, end, pivot);  //用中位数的中位数作为划分的主元
    int leftNum =  p - begin;                 //低区元素的数量 
    if (k == leftNum + 1) {
    	return a[p];
	}
    else if (k <= leftNum) {
    	return select_3(a, begin, p - 1, k);  //在低区递归调用select来找出第k小的元素 
	}
    else {
    	return select_3(a, p + 1, end, k - leftNum -1);  //在高区递归调用select来找出第(k-leftNum-1)小的元素 
	}   
}


int main() {
    FILE *fp = fopen("data_1022.txt","r");            //打开文件 
	if (fp == NULL) {
		printf("Can not open the file!\n");
		exit(0);
	}
	int i = 0;
	while (fscanf(fp, "%d\n", &a[i]) != EOF) {  //读取文件中的数据到数组a[]中 
		i++;
	}
	fclose(fp);                                 //关闭文件 
	printf("Please enter an integer k, and you will get the k-th largest element in the array:\n");
	int k;
	scanf("%d", &k);
	printf("********************* Group length is 5, array size is 945800**********************\n");
	LARGE_INTEGER nFreq;
	LARGE_INTEGER nBeginTime;
	LARGE_INTEGER nEndTime;
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_5(a, 0, i - 1, i - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	double time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("********************* Group length is 7, array size is 945800 **********************\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_7(a, 0, i - 1, i - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("********************* Group length is 3, array size is 945800 **********************\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_3(a, 0, i - 1, i - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("====================== Group length is 5, array size is 10000 ======================\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_5(a, 0, 9999, 10000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("====================== Group length is 7, array size is 10000 ======================\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_7(a, 0, 9999, 10000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("====================== Group length is 3, array size is 10000 ======================\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_3(a, 0, 9999, 10000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("######################## Group length is 5, array size is 1000 ########################\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_5(a, 0, 999, 1000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("######################## Group length is 7, array size is 1000 ########################\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_7(a, 0, 999, 1000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
	
	printf("######################## Group length is 3, array size is 1000 ########################\n");
	QueryPerformanceFrequency(&nFreq);
	QueryPerformanceCounter(&nBeginTime); 
    printf("The %dth largest element in the array is: %d\n", k, select_3(a, 0, 999, 1000 - k + 1));
    QueryPerformanceCounter(&nEndTime);  //计时结束 
	time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart * 1000;
	printf("Running time: %lfms\n\n", time);
    return 0;
}

4. 运行结果

程序使用的测试数据可在本文所附资源处或点击此链接下载。在linearSelect_kth.cpp中，设置分组长度为5。运行该程序，程序循环提示输入整数k，按下回车后会输出第k大的元素，直至输入一个负数或0，程序终止。

在linearSelect_kth_grouplenth_5_vs_7_vs_3.cpp中，大致比较了算法在分组长度为5、7、3以及在不同问题规模的情况下的运行时间。运行该程序，程序提示输入一个整数k，按下回车后，程序依次输出算法分组长度为5、7、3分别在数组长度为945800、10000、1000时的运行时间。

4.1 linearSelect_kth.cpp

  • 第1大： 9999990
  • 第5大： 9999940
  • 第7大： 9999915
  • 第90大： 9998974
  • 第100大：9998835

在这里插入图片描述

4.2 linearSelect_kth_grouplenth_5_vs_7_vs_3.cpp

在这里插入图片描述
在这里插入图片描述
多次运行发现，在数组长度为945800时，基本上运行时间都是组长为7 < 组长为5 < 组长为3。在问题规模减小时，三者的运行时间大小关系略有波动，猜测可能是由于组长为3的select算法是非线性的以及程序运行计时存在误差等。

fufufunny
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
最坏时间为线性的第k大元素的测试数据
04-12
本文件为最坏时间线性的第k大元素的测试数据，每行为1个数字，共945800行，作为数组输入。完整实现代码详见文章https://blog.csdn.net/baidu_40395808/article/details/137073643
最坏情况为线性时间的选择算法
涛爸的博客
07-23 2005
《算法导论》第3版9.3讲解了最坏情况为线性时间的选择算法 步骤如下 1: 将输入数组的n个元素划分为 n/5 组，每组5个元素，且至多只有一组由剩下的 n%5 个元素组成。 2: 寻找 n/5 组中每一组的中位数：首先对每组元素（至多为5个）进行插入排序，然后确定每组有序元素的中位数。 3: 对第2步中找出的 n/5 个中位数，递归调用 select 以找出其中位数 num（如果有偶数个...
算法之线性时间选择（最坏情况下）
WeGoing的博客
09-30 1624
转载自：https://www.cnblogs.com/Not-Famous/p/3653945.html 线性时间选择（Linear Select）: 这个名字不太好理解，什么叫线性时间选择？一句话，在线性时间内完成选择。一般情况下是这样的，我们想要找出一个数组中的最大值或最小值，那就只需要一次排列，然后输出第一个或最后一个元素就行了，但如果是要找出一个数组中的第 k 小的元素呢？ 在一般情况下...
CLRS 9.3最坏情况为线性时间的选择算法
我的专栏
11-16 2173
练习9.3-1、9.3-2、9.3-3、9.3-4、9.3-5、9.3-6、9.3-7、9.3-8、9.3-9
算法设计与分析——顺序统计量：最坏情况为线性时间的选择算法
热门推荐
冯·诺依曼
09-25 1万+
我们现在来看一个最坏情况运行时间为O(n)O(n)O(n)的选择算法。像randomized_select(arr, low, high, i)一样， 下文所述的选择算法通过对输入数组的递归划分来找出所需元素，但是，在该算法中能够保证得到对数组的一个好的划分。 SELECT使用的也是来自快速排序的确定性划分算法 PARTITION （见7.1节），但做了修改，把划分的主元也作为输入参数。 通过执行下列步骤，算法 SELECT可以确定一个有n>1个不同元素的输入数组中第i小的元素。（如果n=1，则 SE
最坏情况为线性时间的选择算法——算法导论P123
qq_39438563的博客
02-28 1646
最坏情况为线性时间的选择算法select与前面的随机选择算法randomied_select的区别在于其主元不是随机选择的（具体如何选择见算法导论P123）。 当我们随机选择主元时，有可能会出现所有元素都在某一边的情况，这种情况使得算法的效率会很低。为了改进这一点，可先将数组划分成若干组，每组五个元素（最后一组可以不足五个元素，这里也可以每组7,9...个元素，但是3个元素...
数据结构--时间复杂度的计算.doc
07-11
但 是我们总是考虑在最坏的情况下的时间复杂度。以保证算法的运行时间不会比它更长。 常见的时间复杂度，按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶 O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、...
第五章 树与二叉树
11-27
在二叉链表存储方式下，从某个结点出发可以直接访问它的孩子结点，但要找到它的双亲结点，则需要从根节点开始搜索，最坏的情况下，需要遍历整个二叉链表。此时采用三叉树链表储存二叉树。 其中，data,lchild,rchild...
图像处理（第二版）章毓晋
10-08
........................................18 B1.2 因为矩阵运算次序是不能互换的，如果改变使用移不变线性操作符的次序会发生什么情况？...................................................................18 B...
Quicksort:利用两种不同的枢轴算法实现Quicksort
04-30
从理论上讲，第二个选择算法由于其最坏情况的线性时间复杂性而应产生更快的运行时间，而最后一个元素枢轴选择应产生最坏情况的O（n ^ 2）时间。 但是，在比较了JUnit中的两个运行时之后，我发现Medians of Medians...
Java 7大排序
m0_74270127的博客
05-10 804
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
第23讲 最短路径
月临水的博客
05-16 293
输入有向图的相关信息，使用Dijkstra算法，求源点到其余顶点的最短路径长度。 注意： （1）使用邻接矩阵存储图的信息 （2）按路径长度递增的次序产生最短路径并输出 若源点到某顶点无路径，则放在最后输出。如：0到1无路径。 输入有向图的相关信息，使用Floyd算法，求每对顶点之间的最短路径长度。 注意： （1）使用邻接矩阵存储图的信息 （2）辅助数组D，记录顶点vi和vj之间的最短路径长度 （3）辅助数组Path，记录最短路径上
基于GA遗传优化的WSN网络最优节点部署算法matlab仿真
最新发布
熟悉python,matlab,C,C++,JAVA等
05-16 199
无线传感器网络（Wireless Sensor Network, WSN）的最优节点部署问题旨在通过合理配置传感器节点的位置，以达到特定的网络覆盖、能耗、寿命或其他性能指标的最大化。假设每个节点的感知范围为R，覆盖目标区域的期望程度可以用覆盖度C 来衡量，通常定义为被至少一个节点覆盖的区域面积与整个监测区域面积的比值。：根据个体的适应度进行选择，适应度高的个体有更高的概率被选中作为“父母”参与下一代的繁殖。：通过交叉操作交换“父母”个体的部分基因，生成新的“子代”个体，以引入多样性。
华为OD机试 - 求幸存数之和（Java 2024 C卷 100分）
学Java，找哪吒
05-13 734
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
每天五分钟计算机视觉：多目标检测模型的Anchor Box算法详解
huanfeng_AI的博客
05-16 96
我们前面学习了目标检测算法，然而算法是有问题的，也就是分割图片的小格子中只能检测到一个对象，如果要是一个小格中有多个对象的中心点，那么这个就没有办法解决了为了解决这个问题，我们可以使用目标检测中的Anchor Box算法，它可以完成这种任务。目标检测中的Anchor Box算法在近年来得到了广泛的应用，尤其在深度学习领域的目标检测任务中，它发挥了至关重要的作用。
代码随想录算法训练营第三十五天| 435. 无重叠区间 763.划分字母区间 56. 合并区间
2301_79829307的博客
05-10 346
再遍历一遍数组，用right和left代表分段的右左区间端点，取right和字母最远的边界的最大值更新right，如果right==i,那就找到了分割点。如果i的左端点>i+1的右端点，把区间的左端点更新为i和i+1左端点的最大值。遍历数组，如果i的右区间大于i-1的左区间，就没有重叠，需要更新左区间。遍历数组，如果i的右区间大于i-1的左区间，就没有重叠，需要更新左区间。先用哈希表遍历一遍数组，同时记录每个字母出现的次数。找到出现过字母的最远边界，该点就是分割点。判断何时更新区间的右端点。
算法练习第22天|39. 组合总和、40.组合总和II
Brillian123的博客
05-15 589
39. 组合总和39. 组合总和 - 力扣（LeetCode）
每周一算法：无向图的最小环
少儿编程乔老师
05-10 745
给定一张无向图，求图中一个至少包含3个点的环，环上的节点不重复，并且环上的边的长度之和最小。该问题称为无向图的最小环问题，可以使用Floyd算法求解。
代码随想录算法训练营第五十五天|LeetCode583.两个字符串的删除操作 、LeetCode72.编辑距离
m0_64514622的博客
05-16 653
dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，最近编辑距离为dp[i][j]word2为空字符串，以i-1为结尾的字符串word1要要删除i个元素才能和word2相同。word1为空字符串，以j-1为结尾的字符串word2要要删除j个元素才能和word1相同。操作三：word1替换word1[i-1]，使其与word2[j-1]相同。
用c++实现最坏情况下为线性时间的选择算法
06-03
好的，让我来回答你的问题。 选择算法是一种在未排序的数组中查找第k小元素的算法。...以上代码实现了一个在最坏情况下为线性时间的选择算法，可以在O(n)的时间复杂度内查找未排序数组中的第k小元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fufufunny

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值