精华内容
下载资源
问答
  • 试题分析:折半查找,首先将待查记录所在范围缩小一半,然后再缩小一半,即对100个元素进行折半查找,第一次比较范围缩小到50,第二次缩小到25,第三次缩小到17,第四次缩小到7,第五次缩小到4,第六次缩小到2,最多...

    CSP-J2019

    5.设有100个已排好序的数据元素,采用折半查找时,最大比较次数为()
    A.7 B.10 C.6 D.8
    答案:A
    试题分析:折半查找,首先将待查记录所在范围缩小一半,然后再缩小一半,即对100个元素进行折半查找,第一次比较范围缩小到50,第二次缩小到25,第三次缩小到17,第四次缩小到7,第五次缩小到4,第六次缩小到2,最多七次就可以查找到所要元素。
    1.

    #include <cstdio>
    #include <cstring>
    using namespace std;
    char st[100];
    int main() {
        scanf("%s", st);
        int n = strlen(st);
        for (int i = 1; i <= n; ++i) {
            if (n % i == 0) {
                char c = st[i - 1];
                if (c >= 'a')
                    st[i - 1] = c - 'a' + 'A';
            }
        }
        printf("%s", st);
        return 0;
    }		
    

    判断题
    1)输入的字符串只能由小写字母或大写字母组成。()
    答案:×
    试题分析:题目没说,可以输入包含其他字符的字符串。

    2)若将第8行的“i=1”改为“i=0”,程序运行时会发生错误()
    答案:√
    试题分析:不能对0取余操作,错误。

    3)若将第8行的“i<=n”改为“ii<=n”,程序运行结果不会改变()
    答案:×
    试题分析:求约数不是判断质数,i
    i<=n只能取到n的前半部分约数。

    4)若输入的字符串全部由大写字母组成,那么输出的字符串就跟输入的字符串一样。()
    答案:√
    试题分析:按题意说明即可判断。

    选择题
    5)若输入的字符串长度为18,那么输入的字符串跟输出的字符串相比至多有()个字符不同。
    A.18 B.6 C.10 D.1
    答案:B
    试题分析:约数个数定理求约数个数。18的约数是:1,2,3,6,9,18。所以最多判定6次。

    6)若输入的字符串长度为(),那么输入的字符串跟输出的字符申相比,至多有36个字符不同。
    A.36 B.100000 C.1 D.128
    答案:B
    试题分析:和上题同理。枚举4个选项。36有9个约数,1有1个约数,128有8个约数。选B。100000有36个约数。
    2.

    #include<cstdio>
    using namespace std;
    int n, m;
    int a[100], b[100];
    
    int main() {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i)
            a[i] = b[i] = 0;
        for (int i = 1; i <= m; ++i) {
            int x, y;
            scanf("%d%d", &x, &y);
            if (a[x] < y && b[y] < x) {
                if (a[x] > 0)
                    b[a[x]] = 0;
                if (b[y] > 0)
                    a[b[y]] = 0;
                a[x] = y;
                b[y] = x;
            }
        }
        int ans = 0;
        for (int i = 1; i <= n; ++i) {
            if (a[i] == 0)
                ++ans;
            if (b[i] == 0)
                ++ans;
        }
        printf("%d", ans);
        return 0;
    }
    

    假设输入的n和m都是正整数,x和y都是在[1,n]的范围内的整数,完成下面的判断题和单选题

    判断题
    1)当m>0时,输出的值一定小于2n。()
    答案:√
    试题分析:按照题意,a数组和b数组赋值为0,a[x] < y && b[y] < x成立,累计计算求和,最终结果肯定小于2n。

    2)执行完第27行的“++ans”时,ans一定是偶数。()
    答案:×
    试题分析:不一定,可以举例求出ans不是偶数的情况。

    1. a[i]和b[i]不可能同时大于0。()
      答案:×
      试题分析:举例即可找到反例。

    4)若程序执行到第13行时,x总是小于y,那么第15行不会被执行。()
    答案:×
    试题分析:同样举例可以实现。

    选择題
    5)若m个x两两不同,且m个y两两不同,则输出的值为()
    2n-2m B.2n+2 C.2n-2 D.2n
    答案:A
    试题分析:根据题意,m次循环中会有2m个位置的值会变化,ans=2n-2m。

    6)若m个x两两不同,且m个y都相等,则输出的值为()
    A.2n-2 B.2n C.2m D.2n-2m
    答案:A
    试题分析:如果m个x各不相同,循环里面的if都不会执行。对数组a,b赋值,只修改了2个位置。也可举例
    3 3
    3 3
    2 3
    1 3
    答案是4。
    在这里插入图片描述
    ① 处应填( )
    A.n%2 B.0 C.t D.1
    答案:C
    试题分析:(猜的话,变量t没有用过。)递归退出判断,参数t的赋值能发现是经常做取反操作。赋值和n没有必然联系,错误。选C。

    ② 处应填( )
    A.x-step,y-step B.x,y-step
    C.x-step,y D.x,y
    答案:D
    试题分析:四个方向,x,y是当前坐标。根据下面参数,参数分别是x,y;x,y+step;x+step,y;x+step,y+step。

    ③ 处应填( )
    x-step,y-step B. x+step,y+step
    x-step,y D. x,y-step
    答案:B

    ④ 处应填( )
    A.n-1,n%2 B.n,0 C.n,n%2 D.n-1,0
    答案:B
    试题分析:第一次调用recursive函数,n是矩阵规模,初始为n,t是取反次数,所以t初始为0或者1。

    ⑤ 处应填( )
    A.i<<(n+1) B.1<<n C.n+1 D.1<<(n-1)
    答案:B
    试题分析:size是输出矩阵的边长,2^n,位运算是1<<n。

    2、(计数排序)计数排序是一个广泛使用的排序方法。下面的程序使用双关键字计数排序,对 n 对 10000 以内的整数,从小达到排序。
    例如有三对整数(3,4)、(2,4)、(3,3),那么排序之后应该是(2,4)、(3,3)、(3,4)。
    输入第一行为 n,接下来 n 行,第 i 行有两个数 a[i] 和 b[i],分别表示第 i 对整数的第一关键字和第二关关键字。
    从小到大排序后输出。
    数据范围 1<n<1071<n<10^7,1<a[i],b[i]<1041<a[i],b[i]<10^4

    提示:应先对第二关键字排序,再对第一关键字排序。数组 ord[]存储第二关键字排序的结果,数组 res[]存储双关键字排序的结果。
    试补全程序

    #include <cstdio>
    #include <cstring>
    using namespace std;
    const int maxn = 10000000;
    const int maxs = 10000;
    
    int n;
    unsigned a[maxn], b[maxn],res[maxn], ord[maxn];
    unsigned cnt[maxs + 1];
    int main() {
        scanf("%d", &n);
        for (int i = 0; i < n; ++i) 
            scanf("%d%d", &a[i], &b[i]);
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < maxs; ++i); // 利用 cnt 数组统计数量
        for (int i = 0; i < n; ++i) 
            cnt[i + 1] += cnt[i];
        for (int i = 0; i < n; ++i); // 记录初步排序结果
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < n; ++i); // 利用 cnt 数组统计数量
        for (int i = 0; i < maxs; ++i)
            cnt[i + 1] += cnt[i];
        for (int i = n - 1; i >= 0; --i)// 记录最终排序结果
        for (int i = 0; i < n; i++)
            printf("%d %d",);
    
        return 0;
    }
    

    1)①处应填()
    A. ++cnt[i]
    B. ++cnt[b[i]]
    C. ++cnt[a[i] * maxs + b[i]]
    D. ++cnt[a[i]]
    答案:B
    解析:此处是对第二关键字进行计数排序。题目中给出提示,先按第二关键字排序。并且根据填空2对ord进行更改, 可知此时是対第二关键字进行排序。

    2)②处应填()
    A. ord[–cnt[a[i]]]=i
    B. ord[–cnt[b[i]]]=a[i]
    C. ord[–cnt[a[i]]]=b[i]
    D. ord[–cnt[b[i]]]=i
    答案:D
    解析:cnt[b[i]]表示按第二关键字,第i个数排第几位。ord[i]表示第i小的数在原序列的位置

    3)③处应填()
    A. ++cnt[b[i]]
    B. ++cnt[a[i] * maxs + b[i]]
    C. ++cnt[a[i]]
    D. ++cnt[i]
    答案:C
    解析:对第一关键字计数,并做各关键词的数量统计工作,因此将a[i]对应的元素数量自增一。

    4)④处应填()
    A. res[-cnt[a[ord[i]]]]=ord[i]
    B. res[-cnt[b[ord[i]]]]=ord[i]
    C. res[-cnt[b[i]]]=ord[i]
    D. res[-cnt[a[i]]]=ord[i]
    答案:A
    解析:对应填空2 ord[i]记录了第二关键字第i小 的数在原序列的位置。此时res[i]记录了第一关键字第i小的数在原序列的位置。

    5)⑤处应填()
    A. a[i],b[i]
    B. a[res[i]],b[res[i]]
    C. a[ord[res[i]]],b[ord[res[i]]]
    D. a[res[ord[i]]],b[res[ord[i]]]
    答案:B
    解析:此处是按顺序输出排序结果,由于之前已经按照第二、第一关键字进行计数排序,所以此时第i 个元素的原始下标为 res[i]。res[i]记录第i个数的原位置。

    展开全文
  • 二分查找

    2019-10-05 00:04:40
    二分查找 对于有序数组来说,折半查找...我们可以进行计算,检验一下折半查找的效率。对于一100元素的有序数组查找一值,所需要的次数不会超过20次,足以说明这算法的优秀性能。 python实现 def sear...

    二分查找

    对于有序数组来说,折半查找的效率很高,它的工作方式主要是通过查找键值K和数组中间元素A[m]来完成的。如果相等,查找结束。否则,K<A[m],就对数组的前半部分进行查找,否则对数组的后半部分进行查找。

    我们可以进行一个计算,检验一下折半查找的效率。对于一个有100万元素的有序数组查找一个值,所需要的次数不会超过20次,足以说明这个算法的优秀性能。

    python实现

    def search_func(search):
        low=0
        high=num-1    
        while low<=high:        
          mid=(low+high)//2        
          if list_num[mid]==search:            
            print('要查找的数的第%d处'%(mid+1))            
            return 0        
          elif list_num[mid]>search:            
            high=mid-1        
          else:            
            low=mid+1    
        else:        
           print('未找到')
    

    欢迎关注公众号 : 数学算法实验室
    专注于算法与人工智能知识

    展开全文
  • 4.已知一有序表为{12,18,24,35,47,50,62,83,90,115,134},当折半查找值为90的元素时,经过( )次比较后查找成功。 A.2 B.3 C.4 D.5 5.已知数据序列为(34,76,45,18,26,54,92,65),按照...
  • 而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1顺序存储结构不足的解决 办法 55 3.6.2线性表链式存储结构定义 56 3.6.3头指针与头结点的异同 58 3.6.4线性表链式存储结构代码描述 58 3.7单链表的读取 60 3.8...
  • 我们如何把现实中大量存在而复杂的问题以*特定的数据类型和特定的存储结构保存到主存储器(内存)中,以及在此基础上为实现某个功能(例如:查找某个元素、删除某个元素,所有元素进行排序)而执行的相应操作...

    概述

    数据结构与算法定义

    我们如何把现实中大量存在而复杂的问题以**特定的数据类型**和**特定的存储结构**保存到主存储器(内存)中,以及在此基础上为实现某个功能(例如:查找某个元素、删除某个元素,对所有元素进行排序)而执行的相应操作,这个相应的操作叫算法。
    

    数据结构 =>个体+个体的关系
    算法 => 对存储数据的操作
    即解决两个问题——个体如何保存?个体与个人之间的关系是怎么保存的?
    是解题的方法和步骤

    衡量算法好坏的标准以及效率度量

    好坏标准

    	1、时间复杂度——程序要执行的次数,而非执行时间
    	2、空间复杂度——算法执行过程中大概所占用的最大内存
    	3、难易程度——别人是否能看懂你的程序
    	4、健壮性——当程序进行一些非法输入时,程序是否会崩溃
    

    效率度量

    1、算法采用的策略和方案
    2、编译产生的代码质量
    3、问题的输入规模
    4、机器执行指令的速度
    
    时间复杂度
    1、定义
    	非用运行时间去度量,而是用运行时进行的基本操作执行次数来度量
    
    2、计算方法:大O推导法
    

    (1)用常数 1 取代运行时间中的所有加法常数
    (2)在修改后的运行次数函数中,只保留最高阶项
    (3)如果最高阶项存在且不是 1,则去除与这个项相乘的常数,得到的结果就是大 O 阶

    3、大O阶大小比较
    

    (1)可以忽略加法常数

    O(2n + 3) = O(2n)

    (2)与最高次项相乘的常数可忽略

    O(2n^2) = O(n^2)

    (3) 最高次项的指数大的,函数随着 n 的增长,结果也会变得增长得更快

    O(n^3) > O(n^2)

    (4)判断一个算法的(时间)效率时,函数中常数和其他次要项常常可以忽略,而更应该关注主项(最高阶项)的阶数

    O(2n^2) = O(n^2+3n+1)
    O(n^3) > O(n^2)

    4、常见时间复杂度:
    在这里插入图片描述

    空间复杂度

    1、定义
    算法的空间复杂度通过计算算法所需的存储空间实现,即运行完一个程序所需内存的大小

    2、空间复杂度的计算
    利用程序的空间复杂度,可以对程序的运行所需要的内存多少有个预先估计
    一个算法所需的存储空间用f(n)表示

    空间复杂度的计算公式记作:S(n)=O(f(n))  
    其中n为问题的规模
    S(n)表示空间复杂度

    (1)忽略常数,用O(1)表示
    (2)递归算法的空间复杂度=递归深度N*每次递归所要的辅助空间
    (3)对于单线程来说,递归有运行时堆栈,求的是递归最深的那一次压栈所耗费的空间的个数
    因为递归最深的那一次所耗费的空间足以容纳它所有递归过程

    一般情况下,一个程序在机器上执行时:

    除了需要存储程序本身的指令,常数,变量和输入数据外

    还需要存储对数据操作的存储单元的辅助空间

    若输入数据所占空间只取决于问题本身,和算法无关

    这样就只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常数,则称此算法为原地工作,空间复杂度为O(1)

    3、需存储的空间
    1)固定部分
    这部分属于静态空间

    这部分空间的大小与输入/输出的数据的个数多少、数值无关

    主要包括指令空间(即代码空间)、数据空间(常量、简单变量)等所占的空间

    (2)可变空间
    这部分空间的主要包括动态分配的空间,以及递归栈所需的空间等

    这部分的空间大小与算法有关

    时间复杂度 vs 空间复杂度
    1、算法的时间复杂度和空间复杂度是可以相互转化的
    2、常用的算法的时间复杂度和空间复杂度
    

    在这里插入图片描述

    预备知识

    1、指针

    1)指针

    	指针就是地址,地址就是指针。
        指针的本质是一个操作受限的非负整数。(虽说是整数,但不能用来做加减乘除运算)
    	指针变量:存放内存单元地址的变量。
    

    指针的重要性:表示一些复杂的数据结构
    快速的传送数据
    使函数返回一个以上的值
    能否直接访问硬件
    能够方便的使用数组和字符串
    是理解面向对象语言中引用的基础
    指针是C语言的灵魂。
    在这里插入图片描述

    #include <stdio.h>
    
    int main(void)
    {
    	int * p;//p是个变量名字,int *表示该p变量只能存储int类型变量的地址
    	int i = 10;
    	int j;
    	return 0;
    }
    
    	①P保存i的地址,p就指向i(*p和i是一个东西)
    	②修改p的值不影响i的值,修改i的值不影响p的值。
    	③*p 是i 
    
    	一个指针变量,无论其指向的变量占几个字节,其自身都是占4个字节。(一个字节一个地址)
    
     	 无论什么类型的变量,实参,返回类型又是void,若想修改其值,**参数必须是其地址**。
    

    注意:
    指针变量也是变量,只不过它存放的不能是内存单元的内容,只能存放内存单元的地址
    普通变量前不能加*
    常量和表达式前不能加&

    #include <stdio.h>
    void f(int *p)  //不是定义了一个名字叫做*p的形参,而是定义了一个形参, 该形参名字叫做p,他的类型是int *; 
    {
    	*p = 100;
    }
    int main(void)
    {
    	int i = 9;
    	
    	f(&i);
    	printf("i = %d\n",i);
    	
    	return 0;
    	
    } 
    

    如何通过被调函数修改主调函数中普通变量的值
    实参(主函数里调用时)为相关变量的地址
    形参为以该变量的类型为类型的指针变量
    Ⅲ 在被调函数中通过 ** 形参变量名* 的方式就可以修改主函数相关变量的值
    =>将实参中的地址传递给形参

    2)指针和数组

    指针 和 一维数组

    数组名
     一维数组名是个指针常量,
     它存放的是一维数组第一个元素的地址, 
     它的值不能被改变
     **一维数组名指向的是数组的第一个元素**
    下标和指针的关系
     a[i] <<==>> *(a+i)
    
    #include <stdio.h>
    int main(void)
    {
    	int a[i] = {1,2,3,4,5};
    	a[3] = *(3+a);  
    	// *a+3 等价于a[0]+3
    	return 0;
    	
    } 
    

    在这里插入图片描述
    假设指针变量的名字为p
    则p+i的值是p+i*(p所指向的变量所占的字节数)

    **指针变量的运算**
     指针变量不能相加,不能相乘,不能相除
     如果两指针变量属于同一数组,则可以相减
     指针变量可以加减一整数,前提是最终结果不能超过指针允许指向的范围
     
      p+i的值是p+i*(p所指向的变量所占的字节数)
      p-i的值是p-i*(p所指向的变量所占的字节数)
      p++  <==> p+1
      p--  <==>   p-1
    
    如何通过被调函数修改主调函数中一维数组的内容【如何界定一维数组】
    
    **需要确定两个参数**
      存放数组首元素的指针变量
      存放数组元素长度的整型变量
    
    #include <stdio.h>
    int main()
    {
    	double *p;
    	double x = 66.6;
    	p = &x;//x占8个字节  1个字节是八位,一个字节一个地址
    	//指针变量里存放首地址
    	
    	
    	double arr[3] = {1.1,2.2,3.3};
    	double *q;
    	
    	q = &arr[0];
    	printf("%p\n",q); //%p实际就是以16进制输出 
    	q = &arr[1];
    	printf("%p\n",q);
    } 
    

    2、结构体

    为什么会出现结构体:
    		为了表示一些复杂的数据,而普通的基本类型变量无法满足要求
    什么叫结构体
    		结构体是用户根据自己需要自己定义的复合数据类型
    如何使用结构体
    注意事项
    	区别Java里的“类”与“结构体”
    
    class Student
    {
    	int sid;
    	String name;
    	int sage;  //定义数据类型
    	void inputStudent()
    	{
    	} 
    	void outputStudent()
    	{
    	}  //具体操作
    }
    //java的“类”,包含定义的数据类型和操作
    
    struct Student
    {
    	int sid;
    	String name;
    	int sage;  //定义数据类型
    };
    //结构体只包含一系列自定义的数据类型
    

    例①:

    #include <stdio.h>
    
    struct Student
    {
    	int sid;
    	char name[200];
    	int sage;
    	}; //分号不要漏了
    
    int main(void)	
    {	
    	struct Student st = {100,"zhangsan",20};
    	printf("%d\n %s\n %d\n", st. sid,st. name, st. sage);
    
    	return 0;
    }
    
    #include <stdio.h>
    #include <string.h> //用到了strcpy()函数,要在头文件定义;
    
    struct Student
    {
    	int sid;
    	char name[200];
    	int sage;
    	}st;
     
    void student(struct Student *pst);
    void g(struct Student st);
    void g1(struct Student *pst);
    
    int main(void)	
    {	
    	//struct Student st; [为st分配好了内存,写在结构体结束的分号前也行]
    	student(&st);
    	
    	g(st);
    	g1(&st); //g1是指针写法,记得把st的地址发送给形参
    	
    	return 0;
    }
    
    //方法一:struct Student st = {100,"zhangsan",20};    =>st,sid  [但是这种方法耗时间、耗内存,不推荐]
    void g(struct Student st)
    {
    	printf("%d\n %s\n %d\n", st. sid,st. name, st. sage);
    
    }
    
    //方法二:struct Student * pst = &st;    =>*pst -> sid   指针pst指向结构体中 的sid这个成员
    void g1(struct Student *pst)
    {
    	printf("%d\n %s\n %d\n", st. sid,st. name, st. sage);
    
    }
    
    void student(struct Student *pst)
    {
    	pst -> sid = 101; //写法二:(*pst).sid = 101;
    	strcpy( pst -> name,"lisi");//strcpy(参数1,"参数2");将参数2 copy到 参数2
    	pst -> sage = 21;
    }
    
    

    3、动态内存的分配和释放

    在这里插入图片描述

    内存是CPU唯一可以直接访问的大容量存储区域,CPU只能访问内存,不能访问硬盘。
    1、地址线:对哪个编号(地址)的单元进行操作  0-(4G-1):32位的电脑,2(32)-1=4G
    					地址:内存单元的编号
    							从0开始的非负整数,范围0-FFFFFFFF  0-(4G-1)
    							可以将地址看做一种数据类型,其int *或是String *
    2、控制线:决定读还是写,只读或是只写
    3、数据线:数据的双向传输。
    
    **传统数组的缺点:**(传统数组即静态数组)
    	1、数组的长度必须事先制定,且只能是常整数,不能为变量
    		eg:
    			int a[5]; //ok
    			int len = 5; int a[len]; //error
    	2、传统形式定义的数组,该数组的内存,程序员无法手动释放。因此在一个函数运行期间,系统为该函数中的数组所分配的空间会一直存在。**直到函数运行完毕时,数组的空间才会被系统释放。**
    	3、数组的长度一旦被定义,其长度就不能再更改。
    		数组的长度不能在函数运行过程中动态地扩充或缩小。
    	4、A函数定义的数组,在A函数运行期间可以被其他函数使用,但在A函数运行完毕之后,A函数中的数组将无法被其他函数使用。
    		传统方式定义的数组不能跨函数使用。
    	
    	**为什么要动态分配内存:**
    		1、动态分配内存很好地解决了传统数组的这四个缺陷
    		2、传统数组即静态数组
    
    **动态数组的构造**
    	eg:
    		假设动态构造一个int型一维数组:
    			int *p = (int *)malloc(int len);
    			
    			1、malloc是memory(内存)allocate(分配)的缩写				
    			2、头文件添加# include <malloc.h>
    			3、malloc函数只有一个形参,形参是整型
    			4、形参表示请求系统为程序分配的字节数
    			5、malloc函数只能返回第一个字节的地址 ,再通过强制类型转换,告诉分配的类型占几个字节,例如int 占4个,char占1个
    			6、p本身占4个字节,是静态的;p所指向的8个字节,是动态的
    			7、动态内存可以直接free(指针)掉 ,p本身的内存函数结束才自动释放
    

    动态内存分配举例:

        //动态地构造一维数组
    	int len;
        printf("请输入需要构造的数组长度:");
        scanf("%d",&len);
        int * arr= (int *)malloc(4*len);
    	//对一维数组操作:赋值
        printf("请输入数组的元素:");
        for (i = 0;i<len;i++)
        {
            scanf("%d",&*(arr+i));
        }
    	//输出
         for (i = 0;i<len;i++)
        {
            printf("%d\n",*(arr+i));//也可以写成arr[i]
        }
    
    
    #include <stdio.h>
    
    int main(void)
    {
     int a[5] = {1,2,3,4,5};
     int len;
     int i;
     printf("input the length:");
     scanf("%d",&len);
    
     int *ptest = (int *)malloc(sizeof(int) * len);//malloc函数只能返回第一个字节地址
     //*ptest = 1;//类似于a[0] = 1;
    //*ptest[1] = 2;//类似于a[1] = 2;
    //我们可直接把ptest当做普通数组来用
    
     for(i =0; i < len; i++)
      scanf("%d",&ptest[i]);
    
     for(i =0; i < len; i++)
      printf( "%d\n", ptest[i]);
    
    free(ptest);
    
     return 0;
    }
    

    5、realloc(数组名,字节数):可以重定义已有的动态数组
    静态内存和动态内存的比较

    	静态内存由系统自动分配,自动释放;
    	静态内存是在栈分配的
    	动态内存由程序员手动分配,手动释放
    	动态内存是在堆分配的
    

    6、跨函数使用内存的问题
    1、静态变量不可以跨函数使用内存
    2、动态内存可以跨函数使用

    展开全文
  • 2. 有10个数存放在一个数组中,输入一个数,要求用折半查找法找出该数是数组中第几个元素的值。如果该数不在数组中,则输出“无此数”。以10个数用赋初值的方法在程序中给出。要找的数用scanf函数输入。 3. 找出一个...
  • java课程实验

    热门讨论 2012-12-02 16:51:19
    然后用索引变量j,对数组中的每一个元素进行循环。在每次内部循环中,将matrix[i][j]赋值为(i*j)。 3) 通过循环打印matrix中的所有元素,结果为: 4、利用二维数组实现一个矩阵类:Matrix。要求提供以下操作...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    <br>实验四 综合(课程设计) 内容及步骤: 1、假定一维数组a[n]中的每个元素值均在[0,200]区间内,用C++编写一个算法,分别统计出落在[0,20],[21,50],[51,80],[81,130],[131,200]等各区间内的元素...
  • 输入一个数,要求用折半查找法找出该数是数组中第几个元素的值。如果该数不在数组中,输出“不在表中”。 39 7.10有一篇文章,共有3行文字,每行有80个字符。要求分别统计出其中英文大写字母,小写字母,数字,空格...
  • 顺序表中第一个元素的储存地址是100,每个元素的长度为2,则第5个元素的地址是() A.100 B.108 C.100 D.120 B 100+(5-1)*2==108 线性表若采用链式存储结构,要求内存中可用存储单元的地址() A.部分是...
  • 顺序表中第一个元素的储存地址是100,每个元素的长度为2,则第5个元素的地址是() A.100 B.108 C.100 D.120 B 100+(5-1)*2==108 线性表若采用链式存储结构,要求内存中可用存储单元的地址() A.部分是...
  • 大话数据结构

    2019-01-10 16:35:22
    而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1顺序存储结构不足的解决 办法 55 3.6.2线性表链式存储结构定义 56 3.6.3头指针与头结点的异同 58 3.6.4线性表链式存储结构代码描述 58 3.7单链表的读取 60 3.8...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1顺序存储结构不足的解决 办法 55 3.6.2线性表链式存储结构定义 56 3.6.3头指针与头结点的异同 58 3.6.4线性表链式存储结构代码描述 58 3.7单链表的读取 60 3.8...
  • 而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1 顺序存储结构不足的解决 办法 55 3.6.2 线性表链式存储结构定义 56 3.6.3 头指针与头结点的异同 58 3.6.4 线性表链式存储结构代码描述 58 3.7 单链表的读取 ...
  • 而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1顺序存储结构不足的解决 办法 55 3.6.2线性表链式存储结构定义 56 3.6.3头指针与头结点的异同 58 3.6.4线性表链式存储结构代码描述 58 3.7单链表的读取 60 3.8...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1 顺序存储结构不足的解决 办法 55 3.6.2 线性表链式存储结构定义 56 3.6.3 头指针与头结点的异同 58 3.6.4 线性表链式存储结构代码描述 58 3.7 单链表的...
  • 实例123 有序数组折半查找 实例124 计算字符串中有多少单词 实例125 获取数组中元素的个数 实例126 输出数组元素 实例127 将二维数组行列对换 实例128 将二维数组转换为一维数组 实例129 使用指针变量遍历...
  • 实例123 有序数组折半查找 实例124 计算字符串中有多少单词 实例125 获取数组中元素的个数 实例126 输出数组元素 实例127 将二维数组行列对换 实例128 将二维数组转换为一维数组 实例129 使用指针变量遍历...
  • 数据结构课程设计

    2014-06-03 13:26:05
    稀疏矩阵转置: 输入稀疏矩阵中每个元素的行号、列号、值,建立稀疏矩阵的三元组存储结构,并将此矩阵转置,显示转置前后的三元组结构。 用头尾链表存储表示法建立广义表,输出广义表,求广义表的表头、广义表的表尾...
  • 数据结构演示软件

    2013-06-02 21:32:36
    (2)折半查找 (Serch_Bin) (3)插值查找 (Search_Ins) (4)斐波那契查找 (Search_Fib) (5)次优查找树(BiTree_SOSTree) 11. 动态查找 (1)在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除...
  • (2)折半查找 (Serch_Bin) (3)插值查找 (Search_Ins) (4)斐波那契查找 (Search_Fib) (5)次优查找树(BiTree_SOSTree) 11. 动态查找 (1)在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除...
  • //根据姓名进行折半查找,不使用递归,返回学生的学号和成绩。 int Search_No(SqList &L,char b[]) { int mid; int low=1; int high=L.length; while(low){ mid=(high+low)/2; if(strcmp(b,L.elem[mid].name...
  • 实例190 泛型化的折半查找法 第9章 编程常用类 9.1 Calendar类的使用 实例191 简单的数字时钟 实例192 简单的电子时钟 实例193 简单的模拟时钟 实例194 简单的公历万年历 实例195 查看生日相关信息 9.2 ...
  • 实例190 泛型化的折半查找法 第9章 编程常用类 9.1 Calendar类的使用 实例191 简单的数字时钟 实例192 简单的电子时钟 实例193 简单的模拟时钟 实例194 简单的公历万年历 实例195 查看生日相关信息 9.2 ...
  • 实例190 泛型化的折半查找法 241 第9章 编程常用类 343 9.1 Calendar类的使用 244 实例191 简单的数字时钟 244 实例192 简单的电子时钟 245 实例193 简单的模拟时钟 246 实例194 简单的公历万年历 248 实例195 查看...
  • 实例190 泛型化的折半查找法 241 第9章 编程常用类 343 9.1 Calendar类的使用 244 实例191 简单的数字时钟 244 实例192 简单的电子时钟 245 实例193 简单的模拟时钟 246 实例194 简单的公历万年历 248 实例195 查看...
  • C语言通用范例开发金典.part2.rar

    热门讨论 2012-08-31 14:18:18
    范例1-50 双向链表的元素个数 124 ∷相关函数:ListLength函数 1.3.20 判断双向链表是否为空 126 范例1-51 判断双向链表是否为空 126 ∷相关函数:ListEmpty函数 1.3.21 双向链表元素值的查询 129 范例1-52 ...
  • 范例1-50 双向链表的元素个数 124 ∷相关函数:ListLength函数 1.3.20 判断双向链表是否为空 126 范例1-51 判断双向链表是否为空 126 ∷相关函数:ListEmpty函数 1.3.21 双向链表元素值的查询 129 范例1-52 ...
  • C 开发金典

    2013-06-20 16:20:03
    范例1-50 双向链表的元素个数 124 ∷相关函数:ListLength函数 1.3.20 判断双向链表是否为空 126 范例1-51 判断双向链表是否为空 126 ∷相关函数:ListEmpty函数 1.3.21 双向链表元素值的查询 129 范例1-52 ...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

对100个元素进行折半查找