编程珠玑 第四章 程序设计

最新推荐文章于 2023-06-17 12:41:03 发布
最新推荐文章于 2023-06-17 12:41:03 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 数据结构和算法设计 文章标签： 编程 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ztz0223/article/details/8022768
版权

1、迭代实现二分查找

int b_s1(int t[], int i, int j, int s)
{
    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    while(1)
    {
        if(i > j)
        {
            return -1;
        }     

        int m = (i + j)/2;

        if(t[m] == s)
        {
            return m;
        }
        else if(t[m] < s)
        {
            i = m + 1;
        }
        else
        {
            j = m - 1;
        }
    }
}


 

2、递归实现二分查找

 

int b_s(int t[], int i, int j, int s)
{
    if(i > j)
    {
        return -1;
    }
    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    int m = (i + j)/2;
    
    if(t[m] == s)
    {
        return m;
    }
    else if(t[m] < s)
    {
        i = m + 1;
    }
    else
    {
        j = m - 1;
    }

    return b_s(t, i, j, s);
}


 

3、习题之一，二分查找第一个出现的查找数据

int b_s2(int t[], int i, int j, int s)
{
    int sch = -1;

    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    while(1)
    {
        if(i > j)
        {
            return sch;
        }     

        int m = (i + j)/2;

        if(t[m] == s)
        {
            sch = m;
            j = m - 1;
        }
        else if(t[m] < s)
        {
            i = m + 1;
        }
        else
        {
            j = m - 1;
        }
    }
}


 

4、完整程序，含测试部分

int b_s(int t[], int i, int j, int s)
{
    if(i > j)
    {
        return -1;
    }
    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    int m = (i + j)/2;
    
    if(t[m] == s)
    {
        return m;
    }
    else if(t[m] < s)
    {
        i = m + 1;
    }
    else
    {
        j = m - 1;
    }

    return b_s(t, i, j, s);
}

int b_s1(int t[], int i, int j, int s)
{
    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    while(1)
    {
        if(i > j)
        {
            return -1;
        }     

        int m = (i + j)/2;

        if(t[m] == s)
        {
            return m;
        }
        else if(t[m] < s)
        {
            i = m + 1;
        }
        else
        {
            j = m - 1;
        }
    }
}

int b_s2(int t[], int i, int j, int s)
{
    int sch = -1;

    if(s < t[i] || s > t[j])
    {
        return -1;
    }

    while(1)
    {
        if(i > j)
        {
            return sch;
        }     

        int m = (i + j)/2;

        if(t[m] == s)
        {
            sch = m;
            j = m - 1;
        }
        else if(t[m] < s)
        {
            i = m + 1;
        }
        else
        {
            j = m - 1;
        }
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    int t[10] ;
    
    for(int i = 0; i < 10; i++)
    {
        t[i] = i + 1;
    }

    int index = b_s(t, 0, 9, 5);
    index = b_s(t, 0, 9, 10);
    index = b_s(t, 0, 9, 10000);
    index = b_s(t, 0, 9, 0);
    index = b_s(t, 0, 9, -1);

    index = b_s1(t, 0, 9, 5);
    index = b_s1(t, 0, 9, 10);
    index = b_s1(t, 0, 9, 10000);
    index = b_s1(t, 0, 9, 0);
    index = b_s1(t, 0, 9, -1);

    index = b_s2(t, 0, 9, 5);
    index = b_s2(t, 0, 9, 10);
    index = b_s2(t, 0, 9, 10000);
    index = b_s2(t, 0, 9, 0);
    index = b_s2(t, 0, 9, -1);

    t[2] = 4;
    index = b_s2(t, 0, 9, 4);

    for(int i = 1; i < 9; i++)
    {
        t[i] = 5;
    }

    index = b_s2(t, 0, 9, 5);

	return 0;
}


 5、第七题
给定一个满足0<= x <= 1的点(x, y)，查找包围这个点的两个线段，前提条件就是0 到 1之间，所有线段不相交，y值递增。

解题分支：
递增可以使用二分查找，直接找最后一个比指定点大的线段，这个线卡要么在最靠近这个点之上，要么这个点就在上面。找到后，索引－1，自然就是最靠近的下面的那个线段了。

 

#include<stdio.h> 

typedef struct point
{
    int x;
    int y;
}POINT;

/*the up_index must be initialised as -1, or something else below the 0*/
void get_approximate_line_up_index(POINT *p, 
                               int low,
                               int high,
                               double d_x,
                               double d_y,
                               int &up_index
                               )
{
    int m = 0;

    if(p[high].x * d_x + p[high].y < d_y)
    {
        return ;
    }

    if(p[low].x * d_x + p[low].y > d_y)
    {
        return ;
    }    
    
    while(1)
    {
        if(low > high)
        {
            return;
        }

        m = (low + high) / 2;

        if(p[m].x * d_x + p[m].y < d_y)
        {
            low = m + 1;
        }
        else if(p[m].x * d_x + p[m].y > d_y)
        {
            up_index = m;
            high = m - 1;
        }
        else 
        {
            up_index = m;
            return ;
        }
    }
}

void print_line_pair(int low, int high, int index)
{
    int m_l = 0;
    int m_h = 0;

    if(low >= high)
    {
        printf("invalid input\n");
        return;
    }

    if(index < low || index > high)
    {
        printf("no match pair\n");
        return;
    }

    if(index == low)
    {
        m_l = low;
        m_h = high;
    }
    else
    {
        m_l = index - 1;
        m_h = index;
    }

    printf("macth pair is (low = %d, high = %d)\n", m_l, m_h);
}

int main() 
{ 
    POINT p[] = {
        { 1, 2},
        { 2, 2},
        { 3, 2},
        { 4, 2},
        { 5, 2},
        { 6, 2},
        { 7, 2},
        { 8, 2},
        { 9, 2},
        { 10, 2},
        { 11, 2},
    };

    int p_size = sizeof p/sizeof p[0];

    /*find the (0.5, 3.1)*/
    double  x = 0.5;
    int     up_index = -1;

    for(int index = 0; index < p_size; index++)
    {
        printf("(x, y) is (%lf, %lf) \n", x, p[index].x * x + p[index].y);
    }

    printf("\n\n");

    get_approximate_line_up_index(p, 0, p_size - 1, x, 3.1, up_index);

    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 4.0, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 4.1, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 4.5, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 4.6, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 5.1, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 5.6, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 6.1, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 6.6, up_index);
    print_line_pair(0, p_size - 1, up_index);

    up_index = -1;
    get_approximate_line_up_index(p, 0, p_size - 1, x, 7.1, up_index);
    print_line_pair(0, p_size - 1, up_index);

}


 

 

就呆在云上
关注
专栏目录
编程珠玑 第二版 修订版
11-01
第4章　编写正确的程序 33 4.1　二分搜索的挑战 33 4.2　编写程序 34 4.3　理解程序 36 4.4　原理 38 4.5　程序验证的角色 39 4.6　习题 40 4.7　深入阅读 42 第5章　编程小事 43 5.1　从伪代码到C程序 43 5.2　测试...
编程珠玑 第二版 修订版 epub
12-27
6. **程序设计思想**：《编程珠玑》提倡模块化设计、代码复用和抽象思维，鼓励程序员以更高级别的视角看待问题，而不是陷入低级实现的细节中。 7. **编程实践**：除了理论知识，本书也提供了丰富的实例，让读者能够...
编程珠玑第八章-性能之算法设计技术
YellowStar5
08-30 798
一.给定一个n元的向量（正负值），如何求最大的连续子向量？ 首先贴一下书中伪代码的Java实现及我的理解package chapter8;import javax.xml.crypto.AlgorithmMethod;//给定n个具有浮点数的向量，求出连续子向量值的最大和 //划归为计算arr[i]到arr[j]的和问题 public class t0 { //第一个算法就是先用两个循环
编程珠玑第九章--性能之代码调优
YellowStar5
09-10 738
大手术–二分搜索 几个程序的书写package chapter9; public class BinarySort { public static int binarySort0(int x[],int number){ int l=0,r=x.length-1; int m=0; while(true){ if(l>
编程珠玑课后习题答案 第一章
雾隐雾现的至渝博客
06-17 546
另一种做法是采用两趟算法，首先使用 5000 000 / 8 = 625 000 个字的存储空间来排序 0 ~ 4 999 999 之间的整数，然后在第二趟排序 5 000 000 ~ 9 999 999 的整数。电话号码的最后两位数字非常接近于随机，因此是非常理想的散列函数，而最前面的两位数字则很不理想——为什么？利用习题 5 的答案，我们可以使用 10 000 000 / 2 个字节在 1 趟内完成对整个文件的排序，或使用 10 000 000 / 2k 个字节在 k 趟内完成对整个文件的排序。
编程珠玑 第4/5/6章
dkjkls的博客
12-17 401
读书笔记 摘自：《编程珠玑-第2版》第4章 编写正确的程序代码的开发是自上而下进行的（从一般思想开始，将其完善为独立的代码行） 正确性分析则是自下而上进行的：从每个独立的代码行开始，检查它们是如何协同运作并解决问题的 初始化 保持 终止 调试过程中，需要同时修正错误代码和错误的断言：总是保持对代码的正确理解 编写简单的代码通常是得到正确程序的关键第5章 编程小事到目前为止，你已经做了
编程珠玑第三章习题答案
坚持
11-02 2376
1 税收问题 .if-else语句的每个分支的形式都差不多，我们可以用数组来使循环简单一点。数组中每个点表明一个阶段，用level[i]表示阶段i的起始点，tax[i]表示阶段i的税率。然后就是输入一个收入，利用二分搜索找到一个最接近于这个收入的税率计算的分段点，当然也可以不用二分搜索找到这个分段点。 int level[100] = { 2200, 2700, ....} doub
编程珠玑——第一章习题解答
Sinhaeng_Hhjian
07-29 593
1、如果不缺内存，如何使用一个具有库的语言来实现以后总排序算法和排序集合？ 答：C++有实现排序的库函数：sort。该函数的实现是快速排序。另外C++的容器Map和set均可以实现排序。由于Map和set的实现是红黑树，所以具有自动排序功能。 快速排序算法实现：     void QuickSort(int *array,int left,int right){   ...
编程珠玑之第二章：杂耍算法
交流学习实践
04-09 718
本文系转载链接 http://www.cnblogs.com/solidblog/archive/2012/07/15/2592009.html 作者在文中的证明思路清晰，不过我只看懂了辗转相除法的证明，杂耍的证明未看懂，但是仔细模拟杂耍算法的过程会有比较直接的体会。 问题：将大小为n的数组向左移动i位 基本原理：      1）先将x[0]移到临时变量t中     2）将x[i
编程珠玑第三章课后习题
chenzujie的博客
09-20 3308
3、编写标语函数，输入一个大写字母，输出一个字符数组，该字符数组用字符图形方式描绘该字母 这题不大懂，百度了下答案，发现答案的重点在于将26个字母用特定的表示方式表示出来，可以考虑为字母的外形设计一个定制模板，自己规定一套模板编写的格式，然后写一个解析程序，每次打印字母时，只需解析字母对应的模板即可，这样主要的工作量就花在每个字母模板的编写上，当然模板的编写是相当简单的，将字母图形转化为相应的模
编程珠玑课后习题答案 第二章
最新发布
雾隐雾现的至渝博客
06-17 436
块交换算法开始时开销最高（可能是由交换单元素块的函数调用引起的），但是良好的高速缓存性能使得旋转距离大于 2 时该算法是最快的算法。为了找出给定单词的所有变位词，我们首先计算它的标识。如果原始的输入文件包含 n 个元素，那么第一趟将读取 n 个整数，第二趟最多读取 n/2 个整数，第三趟最多读取 n/4 个整数，依此类推，所以总的运行时间正比于 n。为了在字典中找出错误的匹配，我们用按键编码标识每个名字，并根据标识排序（当标识相同时根据名字排序），然后顺序读取排序后的文件并输出具有不同名字的相同标识。
编程珠玑 第2版(修订版)_编程珠玑修订_资料_
09-29
《编程珠玑 第2版(修订版)》是一本深受程序员喜爱的经典著作，它不仅提供了丰富的编程实践经验，还深入探讨了程序设计的艺术与智慧。这本书的修订版更是在原版基础上进行了更新和完善，旨在帮助程序员提升编程技能，...
编程珠玑（第二版）答案
07-04
根据提供的标题“编程珠玑（第二版）答案”和描述“编程珠玑（第二版）答案”，我们可以推测出这是关于《编程珠玑》这本书的相关解答资料。《编程珠玑》是一本经典的计算机科学书籍，作者为Jon Bentley。本书旨在...
编程珠玑 Programming Pearls 第二版（中文版+源代码）
07-28
2. **算法设计与分析**：《编程珠玑》强调了算法的重要性，不仅介绍了常见的排序和搜索算法，还讨论了如何在实际应用中选择和改进算法，以提高程序的运行效率。 3. **数据结构的应用**：书中详细讲解了各种数据结构...
字符串查找算法BM算法（Boyer-Moore)算法
大周辞寒的专栏
10-17 8534
字符串查找算法中，最著名的两个是KMP算法（Knuth-Morris-Pratt)和BM算法（Boyer-Moore)。两个算法在最坏情况下均具有线性的查找时间。但是在实用上，KMP算法并不比最简单的c库函数strstr()快多少，而BM算法则往往比KMP算法快上3－5倍。但是，最坏的情况下，BM的时间复杂度貌似也是n×n。具体就不说了，BM算法是通过往后跳动主文本字符串来实现快速非回溯查
构造一棵表达式二叉树
大周辞寒的专栏
09-15 2706
 下面这个程序是我看weiss的《数据结构与算法分析》的第四章的树里面的一个算法写的程序，具体可以看该书的第一版的71页这个给出我的实现，希望来者给出更加好的设计思路。程序里面给出了8种遍历方式，欧拉遍历（其实就是中序加了两个括号而已），前序非递归，中序非递归，后序非递归，前序递归，中序递归，后序递归，另外程序也添加了按层遍历二叉树，程序如下：#include    #
编程珠玑 第八章 习题
大周辞寒的专栏
09-28 2674
8、修改分治算法，使得递归的最坏性能为线性时间 编程珠玑里面提示说，需要记录Last Set Index，于是我便记录之，但是问题是，如此最坏是不能线性的，最好是O(n)，就是左右都是第一个节点的时候。 int subquadratic_conquer(int arry[], int l, int r) { int lmax; int rmax; int sum;
关于算法导论上一道题的思考，求逆序对数目
大周辞寒的专栏
06-11 2467
关于算法导论上一道题的思考，求逆序对数目，时间复杂度为O(nlogn).
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值