递归与分治 | 1：选择算法/中位数 —— 例题：油井

最新推荐文章于 2024-04-26 19:53:25 发布
最新推荐文章于 2024-04-26 19:53:25 发布
阅读量2.7k 收藏 38
点赞数 15
分类专栏： # ③ 递归与分治算法 文章标签： 分治 算法 c语言 中位数 选择算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43787043/article/details/104530024
版权

耐心整理的精品笔记，花点时间耐心看完，相信会有收获 ^_^ ) 

 

本文目录

解法一：RandomizedSelect算法

一、算法描述

1、分（divide）

2、治（conquer）

二、算法实现

1、partition的实现

2、RandomizedSelect的实现 

完整代码：

解法二：BFPTR算法

1、选取pivot

2、partition的实现

3、BFPTR核心算法

完整代码

具体题目

1、油井问题

 

选择问题：找数组a的 [s, e] 范围内的第k小元素。同时，也就能求出中位数。

  • 解法一：RandomizedSelect算法，期望为 O(n) 时间的选择算法。不稳定，会有比较差的O(n^2)时间出现。
  • 解法二：BFPTR算法，最坏情况为O(n) 时间的选择算法。理论上是最快的方法，最坏都是线性时间。

两种算法都是通过分治的思想实现的， BFPTR算法可以说是RandomizedSelect算法的一种改进，写起来稍微麻烦一点。

解法一：RandomizedSelect算法

一、算法描述

对数组a的 [s, e] 范围处理：

1、分（divide）

随机找到一个元素，记为pivot。然后将数组按照与pivot的大小关系分为两部分，分别分到pivot的两边。

其实这个分边的操作有点像快排里面的partiton操作，只是我们的pivot是随机选取的。为了方便，我们选取最后一个元素a[e]为pivot，具体操作如下图所示：

 具体如何移动和实现的，之后会具体说。

2、治（conquer）

现在数组已经分好了，pivot所在位置的下标记为pivot_index，那么在pivot左侧（包括pivot）一共有 pivot_index - s + 1 个元素，记为num。然后判断，第k小元素在哪个部分：

  1. 刚好是pivot：直接返回pivot就行
  2. 在pivot左侧：对pivot左侧的元素 —— 数组a的 [s, pivot_index - 1] 递归地找第k小元素
  3. 在pivot右侧：对pivot右侧的元素 —— 数组a的 [pivot_index + 1, e] 递归地找第k - num 小元素

二、算法实现

1、partition的实现

pivot选取为a[e]，取两个游标 i、j 分别起始指向下标 s 和 e - 1。分别向中间推进，当 i 指向一个大于 pivot 值时停下，当 j 指向一个小于 pivot 值时停下，然后将两者互换。直到 i > j 结束，然后将 pivot 换到合适位置。

下面是具体操作的图解：

主要注意：结束时的条件、pivot 最终移动到合适的位置。

/* 将数组a的[s, e]范围，按照与pivot的大小关系，划分到pivot两侧 *
 * 返回pivot最终的下标
 * 注：pivot是随机选取的 */
int RandomizedPartition(int a[], int s, int e) {
    int pivot = a[e]; //取最后一个元素为pivot来划分
    int i = s, j = e - 1;
    while (i < j) {
        while (a[i] <= pivot && i < e - 1)
            i++;
        while (a[j] >= pivot && j > s)
            j--;
        if (i < j)
            swap(a[i], a[j]);
    }
    swap(a[i], a[e]);  //将pivot移动到合适位置
    return i;
}

2、RandomizedSelect的实现 

/* 找数组a[s, e]范围内的第k小元素 */
int RandomizedSelect(int a[], int s, int e, int k) {
    int pivot_index = RandomizedPartition(a, s, e); //按照与pivot的大小关系，划分到pivot两侧。返回pivot最终的下标
    int num = pivot_index - s + 1; //pivot（包括在内）左侧的元素个数

    if (num == k)//第k小元素恰好是pivot
        return a[pivot_index];
    else if (k < num)   //在pivot左边找
        return RandomizedSelect(a, s, pivot_index - 1, k);
    else  //在pivot右边找
        return RandomizedSelect(a, pivot_index + 1, e, k - num);
}

完整代码：

/* 找数组a[s, e]范围内的第k小元素
 * 特殊情况：中位数... */

#include <algorithm>
using namespace std;

/* 将数组a的[s, e]范围，按照与pivot的大小关系，划分到pivot两侧 *
 * 返回pivot最终的下标
 * 注：pivot是随机选取的 */
int RandomizedPartition(int a[], int s, int e) {
    int pivot = a[e]; //取最后一个元素为pivot来划分
    int i = s, j = e - 1;
    while (i < j) {
        while (a[i] < pivot)
            i++;
        while (a[j] > pivot)
            j--;
        if (i < j)
            swap(a[i], a[j]);
    }
    swap(a[i], a[e]);  //将pivot移动到合适位置
    return i;
}

/* 找数组a[s, e]范围内的第k小元素 */
int RandomizedSelect(int a[], int s, int e, int k) {
    int pivot_index = RandomizedPartition(a, s, e); //按照与pivot的大小关系，划分到pivot两侧。返回pivot最终的下标
    int num = pivot_index - s + 1; //pivot（包括在内）左侧的元素个数

    if (num == k)//第k小元素恰好是pivot
        return a[pivot_index];
    else if (k < num)   //在pivot左边找
        return RandomizedSelect(a, s, pivot_index - 1, k);
    else  //在pivot右边找
        return RandomizedSelect(a, pivot_index + 1, e, k - num);
}

int main() {
    int a[10] = {0, 9, 32, -2, 23, 33, 5, 1, 12, 76};
    printf("中位数：%d\n", RandomizedSelect(a, 0, 9, 10 / 2)); //测试输出中位数（小）
    printf("最大数：%d\n", RandomizedSelect(a, 0, 9, 1)); //测试输出最大数
    printf("最小数：%d\n", RandomizedSelect(a, 0, 9, 10)); //测试输出最小数
    printf("%d\n", RandomizedSelect(a, 0, 9, 7)); //其他测试
}

 

解法二：BFPTR算法

其实RandomizedSelect算法会出现比较差的时间的原因就是：由于pivot是随机选取的，paritition分的不够均匀，导致算法会低效。那么BFPTR算法其实就是在这个问题上改进而来的：我们将pivot选取为一个相对来说靠中间的量，使得partition分配后pivot两侧元素个数差别不多。

1、选取pivot

      既然两个算法的差别就是pivot的选取，那么pivot怎么找呢？通过验证（略，具体看算法书），这样子是最合适的：将数组a的 [s, e] 分组，5个一组，最终不足5个的也分到一组。分别每组进行选择排序，同时能找出每组的中位数，将这些中位数抽出，继续在这些中位数中找"中位数"。

  🔺 注意！ 

      很多算法书上面描述的是找中位数的中位数，其实有些费解，我看了很多资料才明白，这应该是中文书翻译的锅(吐了)。其实应该这样子表述：找中位数的"中位数"，第一个中位数不打引号，是因为确实是每组的中位数的集合；第二个中位数打上了引号，是因为它最后找出的不是真正的中位数，只是一个相对靠中间的数。

  🔺 如何理解呢？

      因为每次将每组的中位数抽出来继续寻找"中位数"，这是一个递归的调用。递归的终点是什么？是最终传入的数组只能分为一组（也就是不超过五个元素），那么这时直接返回第一个元素（不要问为啥，就是近似嘛，可以验证这是合理的）。

     所以说，pivot是一个近似的中位数，而非真正的中位数有这两个原因:

  1. 每组中位数的中位数不一定就是整体的中位数
  2. 况且递归的终点也是近似的，随机找的第一个元素嘛

     理解了pivot如何选取，就可以直接上代码了：

/* 在数组a的[s, e]范围内找到一个大致的"中位数" */
int FindMid(int a[], int s, int e) {
    int cnt = 0; //实时记录分组的编号（从零依次）
    int i;
    /* 五数一组，每组排序后找到中位数，调换到a数组前列 */
    for (i = s; i + 4 <= s; i += 5) {
        InsertSort(a, i, i + 4);  //排序
        swap(a[s + cnt], a[i + 2]); //将中位数调换到a数组前第cnt个
        cnt++;  //小组增加一个
    }
    /* 处理剩余元素 */
    if (i < e) {
        InsertSort(a, i, e); //排序
        swap(a[s + cnt], a[(i + e) / 2]); //将中位数调换到a数组前第cnt个
        cnt++;
    }

    if (cnt <= 1)  //递归的终点：只有一个/没有分组的时候
        return a[s];
    return FindMid(a, s, s + cnt - 1);  //继续递归求解 调到前面的数（每组的中位数）的 "中位数"
}

2、partition的实现

       具体操作和上面描述的RandomizedSelect算法的partition的实现一样，就不重复赘述了，有需要看看上面具体说的。只是pivot是我们的FindMid函数计算出来的。有一点小区别要注意：为了方便移动，pivot需要我们自己最先移动到a[e]位置，最后再移动回合适位置。

      另外有一种特殊情况要注意，就是当序列不需要调整时(pivot为最大元素)，应单独考虑。

      具体代码如下：

/* 将数组a的[s, e]范围，按照与pivot的大小关系，划分到pivot两侧 *
 * 返回pivot最终的下标 */
int partition(int a[], int s, int e, int pivot) {
    int p = FindIndex(a, s, e, pivot);  //找到pivot的下标
    swap(a[p], a[e]);  //将pivot换到最末端
    int i = s, j = e - 1;
    while (i < j) {
        while (a[i] <= pivot)
            i++;
        while (a[j] >= pivot)
            j--;
        if (i < j)
            swap(a[i], a[j]);
    }
    if(a[i] < pivot)   //所有元素都比pivot小，原序列不需要调整
        return e;
    else {
        swap(a, i, e);   //将pivot转到合适位置
        return i;
    }
}

3、BFPTR核心算法

      具体操作和上面描述的RandomizedSelect算法的实现一样是一样的，就不重复赘述了，有需要看看上面具体说的。

/* 找数组的[s, e]范围内第k小元素 */
int BFPTR(int a[], int s, int e, int k) {
    int pivot = FindMid(a, s, e);  //找到一个大致的"中位数"
    int pivot_index = partition(a, s, e, pivot);  //按照与pivot的大小关系，划分到pivot两侧。返回pivot最终的下标
    int num = pivot_index - s + 1;  //pivot（包括在内）左侧的元素个数

    if (num == k)//第k小元素恰好是pivot
        return pivot;
    else if (k < num)   //在pivot左边找
        return BFPTR(a, s, pivot_index - 1, k);
    else  //在pivot右边找
        return BFPTR(a, pivot_index + 1, e, k - num);
}

完整代码

// Created by A on 2020/2/26.

/* 找数组a[s, e]范围内的第k小元素
 * 特殊情况：中位数...
 * 最差时间复杂度为线性 O(N)*/

#include <cstdio>
#include <algorithm>
using namespace std;

/* 增序的插入排序
 * 对数组a的[s, e]范围排序 */
void InsertSort(int a[], int s, int e) {
    for (int i = s + 1; i <= e; i++) {
        int temp = a[i];  //取出待插入元素
        int t = i;  //待插入的位置
        /* 当待插入元素 小于 待插入位置的前一个元素 */
        while (t > 0 && temp < a[t - 1]) {
            a[t] = a[t - 1];  //将前一个元素后移
            t--;  //待插入位置前移
        }
        a[t] = temp;  //插入合适位置
    }
}

/* 在数组a的[s, e]范围内找到一个大致的"中位数" */
int FindMid(int a[], int s, int e) {
    int cnt = 0; //实时记录分组的编号（从零依次）
    int i;
    /* 五数一组，每组排序后找到中位数，调换到a数组前列 */
    for (i = s; i + 4 <= s; i += 5) {
        InsertSort(a, i, i + 4);  //排序
        swap(a[s + cnt], a[i + 2]); //将中位数调换到a数组前第cnt个
        cnt++;  //小组增加一个
    }
    /* 处理剩余元素 */
    if (i < e) {
        InsertSort(a, i, e); //排序
        swap(a[s + cnt], a[(i + e) / 2]); //将中位数调换到a数组前第cnt个
        cnt++;
    }

    if (cnt <= 1)  //递归的终点：只有一个/没有分组的时候
        return a[s];
    return FindMid(a, s, s + cnt - 1);  //继续递归求解 调到前面的数（每组的中位数）的 "中位数"
}

/* 找到数组a的[s, e]范围内 key对应的下标 */
int FindIndex(int a[], int s, int e, int key) {
    for (int i = s; i <= e; i++) {
        if (a[i] == key)
            return i;
    }
}

/* 将数组a的[s, e]范围，按照与pivot的大小关系，划分到pivot两侧 *
 * 返回pivot最终的下标 */
int partition(int a[], int s, int e, int pivot) {
    int p = FindIndex(a, s, e, pivot);  //找到pivot的下标
    swap(a[p], a[e]);  //将pivot换到最末端
    int i = s, j = e - 1;
    while (i < j) {
        while (a[i] <= pivot)
            i++;
        while (a[j] >= pivot)
            j--;
        if (i < j)
            swap(a[i], a[j]);
    }
    swap(a[e], a[i]); //将pivot移动到合适位置
    return i;
}

/* 找数组的[s, e]范围内第k小元素 */
int BFPTR(int a[], int s, int e, int k) {
    int pivot = FindMid(a, s, e);  //找到一个大致的"中位数"
    int pivot_index = partition(a, s, e, pivot);  //按照与pivot的大小关系，划分到pivot两侧。返回pivot最终的下标
    int num = pivot_index - s + 1;  //pivot（包括在内）左侧的元素个数

    if (num == k)//第k小元素恰好是pivot
        return pivot;
    else if (k < num)   //在pivot左边找
        return BFPTR(a, s, pivot_index - 1, k);
    else  //在pivot右边找
        return BFPTR(a, pivot_index + 1, e, k - num);
}

int main() {
    int a[10] = {0, 9, 32, -2, 23, 33, 5, 1, 12, 76};
    printf("中位数：%d\n", BFPTR(a, 0 , 9, 10 / 2)); //测试输出中位数（小）
    printf("最大数：%d\n", BFPTR(a, 0 , 9, 1)); //测试输出最大数
    printf("最小数：%d\n", BFPTR(a, 0 , 9, 10)); //测试输出最小数
    printf("%d\n", BFPTR(a, 0 , 9, 7)); //其他测试
}

具体题目

1、油井问题

 

成绩10开启时间2020年02月25日 星期二 08:55
折扣0.8折扣时间2020年04月30日 星期四 23:55
允许迟交否关闭时间2020年04月30日 星期四 23:55

 

主油管道为东西向，确定主油管道的南北位置，使南北向油井喷油管道和最小。要求线性时间完成。

油井

1<= 油井数量 <=2 000 000

输入要求：

输入有油井数量行，第 K 行为第 K 油井的坐标 X ,Y 。其中， 0<=X<2^31,0<=Y<2^31 。

输出要求：

输出有一行， N 为主管道最优位置的最小值

注意：用快排做的不给分！！

 

友情提示：可以采用while(scanf("%d,%d",&x,&y) != EOF)的数据读入方式。

 测试输入期待的输出时间限制内存限制额外进程
测试用例 1以文本方式显示
  1. 41,969978↵
  2. 26500,413356↵
  3. 11478,550396↵
  4. 24464,567225↵
  5. 23281,613747↵
  6. 491,766290↵
  7. 4827,77476↵
  8. 14604,597006↵
  9. 292,706822↵
  10. 18716,289610↵
  11. 5447,914746↵
以文本方式显示
  1. 597006↵
1秒64M0

本题的x坐标是没有意义的，仔细想想应该知道，最终是需要找出y坐标的中位数才是油管的最佳位置。既然说不能用快排直接找出中位数，那么就可以通过上面的算法来寻找中位数。

我是用BFPTR来实现的，会比较快，完整AC代码如下：

#include <cstdio>
#include <algorithm>

using namespace std;
const int N = 2000005;

int a[N];

/* 增序的插入排序
 * 对数组a的[s, e]范围排序 */
void InsertSort(int a[], int s, int e) {
    for (int i = s + 1; i <= e; i++) {
        int temp = a[i];  //取出待插入元素
        int t = i;  //待插入的位置
        /* 当待插入元素 小于 待插入位置的前一个元素 */
        while (t > 0 && temp < a[t - 1]) {
            a[t] = a[t - 1];  //将前一个元素后移
            t--;  //待插入位置前移
        }
        a[t] = temp;  //插入合适位置
    }
}

/* 在数组a的[s, e]范围内找到一个大致的"中位数" */
int FindMid(int a[], int s, int e) {
    int cnt = 0; //实时记录分组的编号（从零依次）
    int i;
    /* 五数一组，每组排序后找到中位数，调换到a数组前列 */
    for (i = s; i + 4 <= s; i += 5) {
        InsertSort(a, i, i + 4);  //排序
        swap(a[s + cnt], a[i + 2]); //将中位数调换到a数组前第cnt个
        cnt++;  //小组增加一个
    }
    /* 处理剩余元素 */
    if (i < e) {
        InsertSort(a, i, e); //排序
        swap(a[s + cnt], a[(i + e) / 2]); //将中位数调换到a数组前第cnt个
        cnt++;
    }

    if (cnt <= 1)  //递归的终点：只有一个/没有分组的时候
        return a[s];
    return FindMid(a, s, s + cnt - 1);  //继续递归求解 调到前面的数（每组的中位数）的 "中位数"
}

/* 找到数组a的[s, e]范围内 key对应的下标 */
int FindIndex(int a[], int s, int e, int key) {
    for (int i = s; i <= e; i++) {
        if (a[i] == key)
            return i;
    }
}

/* 将数组a的[s, e]范围，按照与pivot的大小关系，划分到pivot两侧 *
 * 返回pivot最终的下标 */
int partition(int a[], int s, int e, int pivot) {
    int p = FindIndex(a, s, e, pivot);  //找到pivot的下标
    swap(a[p], a[e]);  //将pivot换到最末端
    int i = s, j = e - 1;
    while (i < j) {
        while (a[i] <= pivot)
            i++;
        while (a[j] >= pivot)
            j--;
        if (i < j)
            swap(a[i], a[j]);
    }
    swap(a[e], a[i]); //将pivot移动到合适位置
    return i;
}

/* 找数组的[s, e]范围内第k小元素 */
int BFPTR(int a[], int s, int e, int k) {
    int pivot = FindMid(a, s, e);  //找到一个大致的"中位数"
    int pivot_index = partition(a, s, e, pivot);  //按照与pivot的大小关系，划分到pivot两侧。返回pivot最终的下标
    int num = pivot_index - s + 1;  //pivot（包括在内）左侧的元素个数

    if (num == k)//第k小元素恰好是pivot
        return pivot;
    else if (k < num)   //在pivot左边找
        return BFPTR(a, s, pivot_index - 1, k);
    else  //在pivot右边找
        return BFPTR(a, pivot_index + 1, e, k - num);
}


int main() {
    int x, y[N], n = 0;
    while (EOF != scanf("%d,%d", &x, &y[n]))
        n++;
    printf("%d\n", BFPTR(y, 0, n - 1, (n + 1) / 2));

}

结果还是比较理想的，算是比较快：

 

end 

欢迎关注个人公众号“ 鸡翅编程 ”，这里是认真且乖巧的码农一枚。

---- 做最乖巧的博客er，做最扎实的程序员 ----

旨在用心写好每一篇文章，平常会把笔记汇总成推送更新~

 

在这里插入图片描述

贝贝今天AC了吗
关注
  • 15
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
算法设计与分析之输油管道问题
Air_Penguin5291的博客
09-25 1571
输油管道问题 问题描述 某石油公司计划建造一条由东向西的主输油管道。该管道要穿过一个有n口油井的油田。从每口油井都要有一条输油管道沿最短路经（或南或北）与主管道相连。 如果给定n口油井的位置，即它们的x坐标（东西向）和y坐标（南北向），应如何确定主管道的最优位置，即使各油井到主管道之间的输油管道长度总和最小的位置？ 给定n口油井的位置，编程计算各油井到主管道之间的输油管道最小长度总和。 输入 第1...
算法设计与分析 递归与分治策略.docx
11-09
递归与分治策略是算法设计中的重要方法，它们常用于解决复杂问题。本实验报告主要探讨了三种使用递归策略的算法：Ackerman函数实现、大数划分以及数据集合的排列组合。 1. **Ackerman函数实现** Ackerman函数是一...
初阶函数递归经典例题（1）
wangjiushun的博客
02-15 418
1、递归实现n的k次方 2、计算一个数的每位之和（递归实现） 3、strlen的模拟（递归实现）
【C语言初阶（11）】递归练习题
shangguanxiu的博客
07-06 1179
1. 打印一个整型的每一位。2. 求字符串长度。3. 求 n 的阶乘。4. 求第 n 个斐波那契数。5. 字符串逆序。6. 计算一个数的每位之和。7. 递归实现 n 的 k 次方。
【BFPTR】震惊！竟然还有比 快速排序 更快的算法...
最新发布
weixin_46879314的博客
04-26 713
使用 BFPTR 求解 TopK 问题 比快速排序更快的算法？？？
bfptr算法（即中位数的中位数算法）
a3192048的博客
08-25 2万+
BFPRT算法是解决从n个数中选择第k大或第k小的数这个经典问题的著名算法，但很多人并不了解其细节。本文将首先介绍求解这个第k小数字问题的几个思路，然后重点介绍在最坏情况下复杂度仍然为O(n)的BFPRT算法。 一 基本思路 关于选择第k小的数字有许多方法，其效率和复杂度各不一样，可以根据实际情况进行选择。 将n个数排序(比如快速排序或归并排序)，选取排序后的第k个数，时间复杂度为O(nlo...
算法导论 RandomizedSelect
苦海无涯闯进来
04-17 593
1
算法与分析实验一：分治与递归
02-10
实验报告——分治与递归 实验目标是深入理解分治法的核心概念，以及如何将这一方法应用于实际的算法问题中。在这个实验中，我们关注的是如何为具有2的幂次方个选手的网球循环赛制定比赛日程表。实验性质为验证性，...
c语言分治法求众数重数-五大常见算法策略之——递归与分治策略，算法数据结构
04-07
在C语言中，分治法是一种强大的算法设计策略，它将复杂的问题分解为较小的子问题，然后分别解决这些子问题，最后将结果合并得到原问题的解。递归是实现分治法的一种常见手段，它允许函数调用自身来处理更小规模的...
递归与分治算法练习
12-22
一道关于递归与分治算法的练习题如下： 刚拿到题目觉得这题目似乎和递归分治没有什么关系，但是O(1)的空间复杂度，以及O(n)的时间复杂度度就限制了解决方法，也就是分治和递归。（使用python语言只需几行，用切片...
算法递归与分治
01-13
在计算机科学领域，算法是解决问题的关键工具，而“递归与分治”是算法设计中极为重要的策略。本文将深入探讨这两个概念，并结合代码解析，帮助读者理解和掌握它们。 首先，我们来理解“递归”。递归是一种在函数...
线性时间选择中位数算法
06-09
线性时间选择，中位数算法，利用按每5个元素分组，分别找出其中位数，再递归找出
算法导论示例-RandomizedSelect
土豆爸爸的专栏
06-06 1929
/** * Introduction to Algorithms, Second Edition * 9.2 RANDOMIZED-SELECT * @author 土豆爸爸 * */public class RandomizedSelect { /** * 选择数组从p到r之间,第i个最小值。 * @param array 数组
油井问题
weixin_38199770的博客
03-14 3681
油井问题成绩10开启时间2018年03月9日 星期五 14:10折扣0.8折扣时间2018年12月21日 星期五 23:00允许迟交否关闭时间2018年12月22日 星期六 23:00主油管道为东西向，确定主油管道的南北位置，使南北向油井喷油管道和最小。要求线性时间完成。1&lt;= 油井数量 &lt;=2 000 000输入要求：输入有油井数量行，第 K 行为第 K 油井的坐标 X ,Y 。其中...
算法：分治策略经典题目
Kobe51920的博客
01-14 1617
改文章仅供自己作为学习资料！！！ 1.二分搜索技术 问题描述： 大部分程序员应该都知道二分搜索的大致原理，这里不再赘述。需要说明的是二分搜索是所有以比较为基础的搜索算法时间复杂度最低的算法。用二叉树描速二分查找算法，最坏情况下与二叉树的最高阶相同。比较二叉树线性查找也可用二叉树表示，最坏情况下比较次数为数组元素数量。任何一种以比较为基础的搜索算法，其最坏情况所用时间不可能低于O(logn)...
递归整理及几个经典题目
热门推荐
乌枭的博客
11-30 7万+
递归+几个经典题目的解析
经典的递归算法题
大道至简
10-27 3858
1. 斐波那切 (爬楼梯) class Solution { HashMap<Integer,Integer> cache = new HashMap<>(); public int fib(int N) { if (cache.containsKey(N)) { return cache.get(N);...
递归算法详解及经典例题（C语言）
YGQ_qq_1435471912
02-11 1万+
1.递归：在定义一个过程或者函数时出现调用本身或本函数的成分。若调用自身，则称之为直接递归；若过程或者函数P调用过程或者函数Q，而Q又调用P，称之为间接递归，所有的间接递归都可以转换为直接递归，在此，我们只讨论间接递归。我们将包含递归过程的算法称之为递归算法。尾递归是指递归调用语句只有一个而且是处于算法的末尾，例如我们即将提到的求解n!的算法就是尾递归算法。经过分析可知，当递归调用返回时，返回到上...
快速找中位数的算法
weixin_30955341的博客
07-14 2万+
众所周知，quick sort的时间复杂度为O(N*log(N))，利用quick sort的原理可以实现经典的找任意第K大的数的算法：时间复杂度为O(N)。不过这个算法基于快速排序，常数项很大，只是理论上很有意思的方法，但实践中很少拿来用。 找了一下快速计算中位数的方法，找到一篇有趣的报告：“Fast Median Search: an ANSI C implementation”。这篇报告提...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值