C语言专插本知识点

1程序结构

顺序结构、选择结构(分支结构)、循环结构

2.位 字节

bit是位 是指为0或者1，byte是指字节，一个字节 = 八个位

3.基础认识

• c语言编写的程序称为源程序，又称为编译单位
• 只有一个main函数，是程序运行的起点

4.标识符

• 关键词不能作为标识符号
• 预定义标识符：define scanf printf include
  • 可以做为用户标识符

5.进制转换

• 十进制转换成二、八、十六进制

• 二、八、十六进制转换成十进制

• C语言只有八、是、十六进制，没有二进制

  • ！！！但运行的时候，所有的进制都要转换成为二进制来进行处理

• C语言中八进制规定要义 0 开头，八进制没有8，逢8进1

• C语言中十六进制规定要义 0x 开头

• 整型一般是 4个字节， 字符型是 1个字节，双精度一般是 8个字节

  • long int x；表示x是长整型
  • unsigned int x；表示x是无符号整型

6.算术表达式和赋值表达式

6.1算术表达式

• / 两边是整型，结果为整型
• / 一边是小数，结果为小数
• % 余数，求整，两边均需为整型

6.2赋值表达式

• 定义时不可用连续赋值 eg: int x=y=10 ❌
• 定义完变量后，可以连续赋值 eg： int x,y; x=y=10;✔️

6.3自加表达式

++在前 先加后用， ++在后 先用后加 自减表达式相同

7.注释

• 注释不是C语言
• 不占运行时间
• 没有分号
• 不可以嵌套

8.三种取整丢小数的情况

1. int a = 1.6;
2. (int) a;
3. 1/2; 3/2;

9.字符

9.1字符数据的合法形式

• ‘1’ 是字符占一个字节， "1"是字符串占两个字节(含有一个结束符号)
• ‘0’ 的ASCII码表的数值为48，'a’为87，‘A’为65
  • 字符可以进行算术运算 ‘0’ - 0 = 48
  • 大写字母和小写字母的转换的方法 ‘A’ + 32 = ‘a’ 相互之间一般相差32

9.2转义字符

• 转义字符
  • \0 ，\n ，’ ‘’，\
• 八进制转义字符
  • ‘\141’ 合法的，前导的0不能写
• 十六进制转义字符
  • ‘\x6d’ 合法的，前导0不能写，并且x是小写

10.数据输入输出

10.1printf输出

• printf可以只有一个参数，也可以有两个参数
• printf(“xxx”, xxx)；把第二部分的变量、表达式、常量以第一部分的形式展现出来

10.1.1输出格式表格

格式说明	表示内容	格式说明	表示内容
%d	整型 int	%c	字符 char
%ld	长整型 long int	%s	字符串
%f	浮点型 float	%o	八进制
%lf	double	%#o	带前导的八进制
%%	输出一个百分号	%x	十六进制
%5d		%#x	带前导的十六进制

• printf（“%2d”，123 ）； 第二部分有三位，大于指定的两位，原样输出123

  printf（“%5d”，123 ）； 第二部分有三位，小于指定的五位，左边补两个空格xx123 (x表空格)

  printf（“%10f”，1.25 ）； 小数要求补足6位的，没有六位的补0,。结果为xx1.250000 (x表空格)

  printf（“%5.3f”，125 ）； 小数三位，整个五位，结果为1.250（小数点算一位）

  printf（“%3.1f”，1.25 ）；小数一位，整个三位，结果为1.3（要进行四舍五入）

10.2scanf输入

• scanf(“a=%d, b=%d”, &a, &b);
  • 以第一部分的格式在终端输入数据
  • 只有输入 a=12，b=32 才能正确赋值
• scanf(“%d, %d”, x,y)；❌
• scanf(“%d, %d”, &x, &y); ✔️
  • scanf的第二部分一定是要地址

eg：

scanf（“%d”，x） 错误 ； scanf（“%d”，p）正确

scanf（“%d”，&p） 错误 ； scanf（“%d”，*p）错误

10.2.1指定输入的长度

• scanf(“%2d%4d%d”, &x, &y, &z); x为12，y为3456，z为7；
• scanf（“%2d%4d%d”，&x，&y，&z）；x为1，y为2345，z为67

10.2.2输入 字符和整数的区别

• scanf(“%d”, &x);输入1，表示整数1
• scanf(“%c”, &x);输入1，表示是字符‘1’对应ASCII码表的数值为整数48

10.2.3实现保留三位小数，第四位四舍五入的程序

• y=（int）（x*100+0.5）/100.0 这个保留两位，对第三位四舍五入
• y=（int）（x\1000+0.5）/1000.0 这个保留三位，对第四位四舍五入
• y=（int）（x*10000+0.5）/10000.0 这个保留四位，对第五位四舍五入
• -_- => x = （int）x 这样是把小数部分去掉

11.表达式

C语言是用非0表示逻辑真的，用0表示逻辑假的
C语言有构造类型，没有逻辑类型

11.1关系表达式

1. 表达式的数值只能为1(表示真)，或0(表示假)
2. eg: int x= 1,y=0,z=2;则：x 0<2 返回1

11.2逻辑表达式

1. && || ! 三种逻辑运算符号
2. 优先级别： ！ > && > ||

11.3if语句

if语句没有大括号 只包括if后的第一条语句

11.4三元表达式

eg: int x=5,y=1; x > y ? ‘结果为真的返回值’ : ‘结果为假的返回值’

11.5 swtich

• switch只可以和break一起用，不可用和continue用
• case中break；表示退出switch循环
• ⭐case中没有break时，只要有一个case匹配了，剩下的case都需要执行
• switch的条件表达式可以为整型，字符型，枚举和bool(布尔)
• case后：只能为常量或常量表达式

12.函数

1. 函数：是具有一定功能的一个程序块，是C语言的基本组成单位

2. 不能嵌套调用，但可嵌套使用

3. 函数名缺省返回值类型，默认为int

4. 判断质数

   void isPrime(int n){
       for(int i = 2;i< n;i++){
           if(n % i == 0){
               printf("不是质数");
               break;
           }else {
               printf("是质数");
               break;
           }
       }
   }
   
   int main(){
         int x;
       printf("输入一个正整数: ");
       scanf("%d",&x);
       isPrime(x);
   }
   

5. 求阶层

   1. int jiecen(int n){
          int result = 1;
          for(int i = 1;i<=n;i++){
              result *= i;
          }
          return result;
      }
      int main(){
          int x;
          scanf("%d", x);
          printf("%d", jiecen(x));
      }
      

6. 参数传递

   1. 传 数值，形参的变化不会改变实参的变化
   2. 传 地址，形参的变化有可能改变实参的变化

13.指针

指针变量的本质是用来存放地址，而一般的变量是存放数值的

不同类型的指针变量不能赋值，不同类型的指针变量不能赋值

13.1 *p 和 p差别

• *p是数值，p是地址
• *p可以作为变量使用，✳的作用是取后面地址p里的数值
• p是当作地址来使用。可以用在scanf函数中：scanf(“%d”, p);

13.2**p++ 和（* *p）++的差别

• *p++是地址会变化。 取当前值，然后再移动地址

• (*p)++ 是数值会变化。取当前值，然后再是数值增加1

• 例题：int *p,a[]={1,3,5,7,9};p=a;
        请问*p++和（*p）++的数值分别为多少？
        *p++：  这个本身的数值为1。由于是地址会增加一，所以指针指向数值3了。  
  （*p）++ 这个本身的数值为1。由于有个++表示数值会增加，指针不移动，但数值1由于自加了一次变成了2。   
  
  

13.3二级指针

• *p：一级指针：存放变量地址

• **q：二级指针：存放一级指针的地址

•  int x=7；
                 int*p=&x，**q=p；
                 问你：*p为多少？*q为多少？**q为多少？
                         7           p         7
                 再问你：**q=&x的写法可以吗？   
                        不可以，因为二级指针只能存放一级指针的地址。
    
  

13.4移动指针

• char *s="meikanshu";   
  while(*s){
      printf("%c"，*s);
          s++;
  }
  //这个s首先会指向第一个字母m然后通过循环会一次打印出一个字符，s++是地址移动，打印了一个字母后，就会移动到下一个字母
  

13.5指针变量初始化

1. int a = 2; *p = &a;(定义的同时初始化)
2. int a = 2,*p; p = &a;(定义之后初始化)

13.6传数值和传地址

//传数值									传地址
void fun（int a，int b）                     void fun（int *a，int *b）             
{ int t ；                                       { int t ；
  t=a；a=b；b=t；                                  t=*a；*a=*b；*b=t；
}                                                }
main（）                                     main（）
{ int x=1，y=3，                             { int x=1，y=3，
  fun（x，y）；                                 fun（&x，&y）
  printf（“%d，%d”，x，y）；                    printf（“%d，%d”，x，y）；
}                                             }
这个题目答案是1和3。                         这个题目的答案就是3和1。
传数值，fun是用变量接受，所以fun中      	   传地址，fun用指针接受！这个时候fun
的交换不会影响到main中的x和y 。        		中的交换，就会影响到main中的x和y。
传数值，形参的变化不会影响实参。          	 传地址形参的变化绝大多数会影响到实参！ 

13.7函数返回值是地址

int *fun(int *a，int *b)   //可以发现函数前面有个*，这个就说明函数运算结果是地址
{ if(*a>*b)return a;     //return a 可以知道返回的是a地址。
  else return b;                                                                         
}
main()
{ int x=7，y=8，*max；
  max = fun(&x，&y);     //由于fun（&x，&y）的运算结果是地址，所以用max来接收。
  print("%d", max);    
}       

13.8三名主义

1. 数组名：表示第一个元素的地址。(数组名不可用自加，它是地址常量名)
2. 函数名：表示该函数的入口地址
3. 字符串常量名：表示第一个字符的地址

指针变量是存放地址的。并且指向哪个就等价哪个，所有出现*p的地方都可以用它等价的代替

13.9 指针和指针变量

1. 概念不同：指针是概念，指针变量是具体实现
2. 存放地址不同：
   1. 指针存储一个变量的内存地址，指针就是地址，地址就是指针
   2. 指针变量是存放内存地址的变量

TIP:

指针变量是存放地址的。并且指向哪个就等价于哪个，所有出现*p 的地方都可以用它等价的代替

• eg:

  • int a = 2, *p = &a;
    *p = *p + 2;
    //由于*p指向变量a，所以指向哪个就等价哪个，这里的*p等价于a，相当于是 a = a + 2
    

14.数组

数组：存放的类型是一致的。多个数组元素的地址是连续的；

14.1初始化

int a[5]={1,2,3,4,5};  合法
int a[5]={1,2,3, };    合法
int a[]={1,2,3,4,5};   合法,常考，后面决定前面的大小！
int a[5]={1,2,3,4,5,6}; 不合法，赋值的个数多余数组的个数了

14.2定义

int a[5]；注意这个地方有一个重要考点，定义时数组的个数不是变量一定是常量。
int a[5]                  合法，最正常的数组
int a[1+1]                合法，个数是常量2，是个算术表达式
int a[1/2+4]              合法，同样是算术表达式
int x=5,int a[x];           不合法，因为个数是x，是个变量，非法的，
define P 5   int a[P]       合法，define 后的的P是符号常量，只是长得像变量

14.3二维数组初始化

int a[2][3]={1,2,3,4,5,6};               合法，很标准的二维的赋值。
int a[2][3]={1,2,3,4,5, };                合法，后面一个默认为0。
int a[2][3]={{1,2,3,} {4,5,6}};           合法，每行三个。
int a[2][3]={{1,2,}{3,4,5}};             合法，第一行最后一个默认为0。
int a[2][3]={1,2,3,4,5,6,7};              不合法，赋值的个数多余数组的个数了。
int a[][3]={1,2,3,4,5,6};                合法，可以缺省行的个数。
int a[2][]={1,2,3,4,5,6};                不合法，不可以缺省列的个数。
行可省 列不可省:https://blog.csdn.net/LivingMu/article/details/111030270

14.4补充

1. 一维数组的重要概念

   1. 对a[10]这个数组的讨论
      1. a表示数组名，是第一个元素的地址，也就是元素a[0]的地址(等价于&a)
      2. a是地址常量，所以只要出现a++，或者是a=a+2赋值都是❌的
      3. a是一维数组名，它是列指针，也就是a+1是跳一列
   2. 对a[3] [3]的讨论
      1. a是数组名，第一个元素的地址，也就是a[0] [0]的地址
      2. a是地址常量，所以只要出现a++，或者是a=a+2赋值都是❌的
      3. a是二维数组行，它是行指针，也就是a+1是跳一行
      4. a[0]、a[1]也都是地址常量，不可以对它进行赋值操作，同时它们都是列指针，+1后 都是跳一列
      5. 注意a和a[1]、a[0]是不同的，它们的 基类型是不同的。前者是一行元素，后者是一列元素

2. 二维数组做题技巧

   1. 如果有a[3][3]={1,2,3,4,5,6,7,8,9}这样的题目。
      步骤一：把他们写成：　　　　　　
      	   第一列　第二列　第三列　　
      a[0]－>　 1 　　  2  　　 3   －>第一行
      a[1]－>   4   　　5  　　 6　 —>第二行
      a[2]－>   7   　　8  　　 9　 －>第三行
      步骤二：这样作题目间很简单：　　　　
      *(a[0]+1)我们就知道是第一行的第一个元素往后面跳一列，那么这里就是a[0][1]元素，所以是１。
      *(a[1]+2)我们就知道是第二行的第一个元素往后面跳二列。那么这里就是a[1][2]元素，所以是6。
      一定记住：只要是二维数组的题目，一定是写成如上的格式，再去做题目，这样会比较简单。
      

3. 数组初始化

   1. int a[]={1，2} 合法。   int a[][4]={2，3，4}合法。   但int a[4][]={2，3，4}非法。
      

4. 二维数组中的行指针

   1. int a[1][2];
      //其中a现在就是一个行指针，a+1跳一行数组元素搭配（*）p[2]指针
           
      //a[0]，a[1]现在就是一个列指针。a[0]+1 跳一个数组元素。搭配*p[2]指针数组使用
      

5. 脱衣服法则

   1. a[2] 变成 *（a+2） a[2][3]变成 *（a+2）[3]再可以变成 *（*（a+2）+3）

15.C语言的特点

1. 语言简洁，紧凑使用方便 灵活(37个关键词，9种控制语句)
2. 运算符丰富(34种运算符)
3. 数据类型丰富
4. 具有结构化的控制语句
5. 语法限制不太严格，程序设计自由度大
6. 允许直接访问物理地址、能进行位操作，可以直接对硬件进行操作
7. 可移植性好
8. 生成目标代码质量高，程序执行效率高

16.C语言程序的结构特点

1. 一个程序由一个或多个源程序文件组成
2. 函数是C程序的主要组成部分
3. 一个函数包括两个部分(函数首部，函数体(声明、执行部分))
4. 程序总是从main 函数开始执行
5. C程序对计算机的操作由 C 语句完成
6. 数据声明和语句最后必须要有分号 ;
7. C语言本身不提供输入输出语句(由C标准函数库中的函数来实现的)
8. 程序应当包含注释，增强可读性

17.算法–程序的灵魂

17.1一个程序主要包括两部分

1. 对数据的描述
   1. 再程序中要指定用到哪些数据以及这些数据的类型和数据的组织形式，这就是 数据结构
2. 对操作的描述
   1. 要求计算机进行操作的步骤，也就是 算法

数据是操作的对象，操作的目的是对数据进行加工处理，得到期望的结果

算法 + 数据结构 = 程序

17.2.算法是什么

• 数值运算算法 (目的是求数值解)
• 非数值运算算法 (包括面十分广泛，常用于事务管理领域)

17.3算法的特性

1. 有穷性。有限的操作步骤
2. 确定性。每一个步骤都是确定的
3. 有零个或多个输入。执行算法时需要从外界取得必要的信息
4. 有一个或多个输出。算法的目的是为了求解，没有输出算法没有意义
5. 有效性。算法中的每一个步骤都能有效地执行

17.4三种基本结构和改进的流程图

1. 顺序结构
2. 选择结构
3. 循环结构
4. 当型循环结构
5. 直到型循环结构
6. 三种基本结构和改进的流程图_weixin_30678349的博客-CSDN博客

17.5结构化程序设计方法

1. 自顶向下
2. 逐步细化
3. 模块化设计
4. 结构化编码

17.6结构化设计的三种基本结构

1. 顺序结构
2. 分支结构
3. 循环结构

18.简单的C程序设计

19.数据类型

1.类型强转

2.字符数据的输入输出

20.选择结构程序设计

1.关系运算符优先次序

• 关系、算术、赋值运算符的优先级：算数运算符 > 关系运算符 > 赋值运算符

2.逻辑运算符优先次序

• 逻辑运算符的优先次序： ! → && → || （! 为三者中最高）
• 与其他运算符的优先次序：赋值运算符 < &&和|| < 关系运算符 < 算数运算符 < ！

21.do–whille语句特点

• 先无条件地执行循环体，然后判断循环条件是否成立

22.break 和 continue的区别

• continue 只是结束本次循环，而不是终止整个循环的执行
• break 结束整个循环过程，不再判断执行循环的条件是否成立

23.C函数库专门处理字符串的函数

24.函数调用形式

1.函数调用时的数据传递

• 形式参数(形参)，定义函数时函数名后面的变量名
• 实际参数(实参)，主函数调用函数时，函数名后面的参数

25.被调用函数的声明

一个函数中调用另一个函数需要具备：

1. 被调用函数必须是已经定义的函数(是库函数或用户自己定义的函数)
2. 如果使用库函数，应该再本文箭头加对应的 #include 指令
3. 如果使用自己定义的函数，而该函数的位置再调用它的函数后面，应该声明

26.函数原型

两中形式：

1. float add(float x, float y);
2. float add(float, float);
   1. 原型说明可以放在文件的开头，这时所有函数都可以使用此函数

27.动态、静态存储方式

28.格式转换说明符

转换说明	输 出
%a	浮点数、十六进制数字和p-记数法 (C99)
%A	浮点数、十六进制数字和P-记数法 (C99)
%c	一个字符
%d	有符号十进制整数
%e	浮点数、e-记数法
%E	浮点数、E-记数法
%f	浮点数，十进制记数法
%g	根据数值不同自动选择%f或者%e。%e格式在指数小于-4或者大于等于精度时使用
%G	根据数值不同自动选择%f或者%E。%E格式在指数小于-4或者大于等于精度时使用
%i	有符号十进制整数 (与%d相同)
%o	无符号八进制整数
%p	指针(就是指地址)
%s	字符串
%u	无符号十进制整数
%x	使用十六进制数字0f 的无符号十六进制整数
%X	使用十六进制数字0F的无符号十六进制整数
%%	打印一个百分号

29.%ns输出

printf("\n*s1=%15s*", "chinabeijing");
printf("\n*s2=%-5s*", "chi");
//输出结果
*s1=   chinabeijing*
*s2=chi  *

n为正数（右对齐）：
	1.长度等于字符长度输出完整字符数组
	2.长度大于字符数组长度，输出:(n - len)个空格 + 字符串数组
n为负数（左对齐）：
	1.长度等于字符长度输出完整字符数组
	2.长度大于字符数组长度，输出:字符串数组 + (n - len)个空格

30.文件

文件一般包括三要素：文件路径、文件名、后缀

C语言不仅支持对当前目录和根目录文件的操作，也支持对多级目录文件的操作

文件路径

在 C 语言中 ’ \ ’ 一般是转义字符的起始标志，故在路径中需要用两个 ’ \ ’ 表示路径中目录层次的间隔，也可以使用 ‘/’ 作为路径中的分隔符

eg：D:\ \C_WorkSpace\ \Chapter_10\ \file_1.txt

D:/C_WorkSpace/Chapter_10/file_1.txt

分类

1. 逻辑结构

   1. 记录文件

      1. 顺序文件
      2. 索引文件
      3. 索引顺序文件
      4. 散列文件

   2. 流式文件

      1. 以字节为单位，对流式文件的访问一般采用穷举搜索的方式，效率不高

         但管理简单

流的概念及分类

把抽线出来的“标准逻辑设备”或“标准文件”称作‘流’

按方向分为：输入流和输出流

按数据形式分为：文本流(ASCII码字符序列/字符序列)和二进制流(字节序列)

文本文件与二进制文件

根据文件中数据的组织形式的不同分类

• 文本文件(字符序列文件):把存储的数据当初一系列字符组成，把每个字符的ASCII码值存入文件中
• 二进制文件(字节序列文件):把数据对应的二进制形式存储到文件中

缓冲和非缓存文件系统

缓冲文件系统(标准文件系统)

非缓冲文件系统

ANSI C标准中只采用缓冲文件系统

• 缓冲文件系统：系统自动为每个打开的文件在内存开辟一块缓冲区，缓冲区的大小一半由系统决定
• 非缓冲区系统：系统不自动为打开的文件开辟内存缓冲区，由程序设计者自行设置缓冲区及大小

文件的打开与关闭

调用标准库stdio.h中的fopen和fclose函数实现

fopen:

FILE* fopen(char *filename, char *mode);

参数说明:

1. filename：文件名，包括路径，如果不显示含有路径，则表示当前路径

2. mode：文件打开模式

   1. 模式	含 义	说 明
      r	只读	文件必须存在，否则打开失败
      w	只写	若文件存在，则清除原文件内容后写入；否则，新建文件后写入
      a	追加只写	若文件存在，则位置指针移到文件末尾，在文件尾部追加写人，故该方式不 删除原文件数据；若文件不存在，则打开失败
      r+	读写	文件必须存在。在只读 r 的基础上加 ‘+’ 表示增加可写的功能。下同
      w+	读写	新建一个文件，先向该文件中写人数据，然后可从该文件中读取数据
      a+	读写	在” a”模式的基础上，增加可读功能
      rb	二进制读	功能同模式”r”，区别：b表示以二进制模式打开。下同
      wb	二进制写	功能同模式“w”。二进制模式
      ab	二进制追加	功能同模式”a”。二进制模式
      rb+	二进制读写	功能同模式"r+”。二进制模式
      wb+	二进制读写	功能同模式”w+”。二进制模式
      ab+	二进制读写	功能同模式”a+”。二进制模式

读写函数：

1. 字符读写函数 ：fgetc和fputc
2. 字符串读写函数：fgets和fputs
3. 数据块读写函数：freed和fwrite
4. 格式化读写函数：fscanf和fprinf

31.逗号表达式

优先级别最低。表达式的数值逗号最右边的那个表达式的数值

z = (2,3,4) （整个是赋值表达式） z的值为4
z = 2,3,4	（整个是逗号表达式） z的值为2

32.布尔位运算符

运算符	意义	示例	对于每个位位置的结果（1=设定，0=清除）
&	位 AND	x&y	如果 x 和 y 都为 1，则得到 1；如果 x 或 y 任何一个为 0，或都为0，则得到 0
|	位 OR	x|y	如果 x 或 y 为 1，或都为 1，则得到 1；如果 x 和 y 都为 0，则得到 0
^	位 XOR	x^y	如果 x 或 y 的值不同，则得到 1；如果两个值相同，则得到 0
~	位 NOT（I的补码）	~x	如果 x 为 0，则得到 1，如果 x 是 1，则得到 0

• 位运算符的操作数必须是整数类型，并且遵循寻常算术转换（usualarithmetic conversion）。转换后获得的操作数通用类型就是整个计算结果的类型

33.赋值运算符

34.移位运算符

运算符	意义	示例	结果
<<	向左移位	x<	x 的每个位向左移动 y 个位 相当与x乘以y次2
>>	向右移位	x>>y	x 的每个位向右移动 y 个位 相当与x除以y次2

• 移位运算符的操作数必须是整数
• 移位运算结果的类型等于左操作数在整数提升后的类型
• 移位运算符的优先级比算术运算符的优先级更低，但相对于比较运算符以及其他的位操作运算符，具有更高的优先级

35.strlen与sizeof

strlen：是一个函数，用来计算指定字符串str的长度，但不包括结束字符(即null字符)

sizeof：是一个单目运算符，而不是一个函数.(参数可以是数组、指针、类型、对象、函数等)

36.二元组

数据结构的二元组形式为：DS=（D，S）

D是数据元素的集合；S是D中数据元素之间的关系集合（使用序偶来表示）

序偶:

序偶是由两个元素x和y按一定顺序排列而成的二元组，记作,x是第一个元素，y是第二个元素

分类情况：

37.各排序需要的辅助空间总结

1. 选择排序
   1. 简单选择排序：1个
   2. 堆排序： 1个
2. 交换排序
   1. 冒泡排序：1个
   2. 快速排序：最好：log2n 最坏：n 平均log2n
3. 插入排序
   1. 直接插入：1个
   2. 折半插入：1个
   3. 希尔排序：1个
4. 归并排序： n个
5. 基数排序： r ( r个人队列：r个头指针和r个队尾指针)

38.各排序稳定性总结

• 稳定排序
  1. 直接插入排序
     2. 冒泡排序
     3. 归并排序
     4. 基数排序
• 不稳定排序
  1. 希尔排序
  2. 直接选择排序
  3. 堆排序
  4. 快速排序

39.堆与二叉排序树的区别

• 以小根堆为例，堆的特点是双亲结点的关键字必然小于等于孩子节点的关键字，而两个孩子节点的关键字没有次序规定
• 二叉排序树中，每个双亲结点的关键字均大于左子树结点的关键字，每个双亲结点的关键字均小于右子树结点的关键字，每个双亲结点的左右孩子的关键字是有次序关系的

40.全局变量

全局变量全部存放在静态存储区，程序开始执行时给全局变量分配存储区，在程序结束时释放

1. 在所有函数外部定义的变量称为全局变量
2. 它的作用域默认是从定义变量的位置到本源文件结束都有效
3. 最好直接定义到文件的最顶部

int pointnum; // 全局变量 (最好定义与文件头)

extern int pointnum; //调用是需加关键字extern    

41.邻接矩阵

1. 横向出度
2. 纵向入度

42.C语言函数的存储类别

1. auto：只能用于局部变量
2. extern：允许被其他文件调用
3. static：只能被本源程序文件调用
4. 函数默认的隐含存储类型是extern

43.文件指针定义

FILE *指针名;
定义了一个指针为fp,这个指针以后只能指向文件，之后要把文件的首地址赋值给该指针
FILE *fp;

44.用8位无符号二进制数能表示的最大十进制数为

8位无符号二进制数就是从00000000到11111111

转换成10进制就是0到255

所以最大的就是255

45.复合语句

• C语言中，复合语句简称语句块 用括号{}括起来组成的一个语句称复合语句
• 所以在一个函数内复合语句中定义的变量只在其复合语句范围内有效

46.C语句

1. 表达式语句
   1. 表达式;
   2. eg：c=a+a;
2. 函数调用语句
   1. 函数名(实际参数表);
   2. eg：printf(“HELLO WORLD!”);
3. 控制语句
   1. 条件判断语句：if、switch
   2. 循环执行语句：do while，while，for
   3. 转向语句：break，goto，continue，return
4. 复合语句
   1. {} 内的语句
   2. int fun(){int a = 2;printf(“%d”, a);}
5. 空语句
   1. 只有分号“;”组成的语句称为空语句
   2. eg：while( getchar()!=‘\n’ );

47.二维数组存储地址计算

设二维数组Arr [x] [y]，初始地址Arr[0] [0]为1000，每个元素占q个字节，求Arr[n] [m]的存储地址

• 1000 + （y * n + m）*q

• 

• 1000 + (4 * 3 + 3) * 2 = 1030

48.int类型大小

• int类型只占用两个字节的存储空间，数的大小在：-32768-32767之间

49.⭐关于一趟排序后，未必有一个元素在放在最终位置上：

1. 堆排序每趟总能选出一个最大值或最小值位于根结点，属于选择排序
2. 冒泡排序会将最大/最小值置于数组最后/最前
3. 快速排序中基准是可以放在最终的位置的，属于交换排序
4. 简单选择排序 能够选出无序序列中最大/最小的与相应位置互换
5. 希尔排序属于插入排序，插入排序是不能保证在第一次排序后放在最终位置的

• 只有 简单选择、快速、冒泡、堆排序一定有元素在它的最终位置上

50.森林的两种遍历方法

• 先序遍历森林和中序遍历森林

51.二叉判定树

【折半查找二叉判定树】_CD4356的博客-CSDN博客_二叉判定树

52.循环队列

• n为数组长度
• 队满时：(rear + 1)%n == front
• 队空时：rear == front
• 每删除一个元素，队首指针：front=(front + 1)%n
• 每插入一个元素，队尾指针：rear = (rear + 1)%n
• 循环队列元素个数：（rear-front+n)% n
• 3，0

53.线性表操作平均移动次数

• 删除：(n-1)/2
• 插入：n/2
• 

54.查找算法的时间复杂度

• 顺序查找O(n)
• 分块查找O(log2n)到O(n)之间
• 二分查找O(log2n)
• 哈希查找O(1)

55.⭐散列表查找 平均查找长度

• 画出对应的散列表

散列地址	0	1	2	3	4	5	6	7	8	9	10
元素	11	22		47	92	16	3	7	29	8
比较次数	1	2		1	1	1	4	1	2	2

• 计算ASL=(全部元素比较次数) / 元素个数
• ASL = (1+2+1+1+1+4+1+2+2) / 9 = 5/3

56.拓扑排序,拓扑序列,关键路径

1. 拓扑排序：将 AOV 网中所有活动排成一个序列，使得每个活动的前驱活动都排在该活动的前面。
2. 拓扑序列：经过拓扑排序后得到的活动序列（一个 AOV 网的拓扑序列不是唯一的）。
3. 关键路径：AOV 网中从源点到汇点的最长路径的长度（一个 AOV 网中的拓扑排序不是唯一的）

57.类型默认转化规则

char --> short --> int —> unsigned --> long --> unsigned long --> float --> double

58.数据的物理结构

1. 顺序存储结构
2. 链式存储结构

59.链式队列

• 链式队列，队列篇（链式队列的出队入队操作）_IC00的博客-CSDN博客_链队列出队操作

60.已知树的序列能否确定二叉树

• 已知前序遍历和中序遍历，可以唯一确定一颗二叉树
• 已知后序遍历和中序遍历，可以唯一确定一颗二叉树
• ⭐没有中序遍历的情况下无法确定一颗二叉树

61.数据结构

计算机存储、组织数据的方式，相互之间存在一种或多种特定关系的数据元素的集合

62.递归和迭代

递归（recursion）：递归常被用来描述以自相似方法重复事物的过程，在数学和计算机科学中，指的是在函数定义中使用函数自身的方法。（A调用A）

迭代（iteration）：重复反馈过程的活动，每一次迭代的结果会作为下一次迭代的初始值。（A重复调用B）

63.折半查找二叉判定树

选取序列中间结点作为根结点，分为左右部分并重复选取序列中间结点作为根结点

64.二叉判定树，具有以下性质：

1. 若左子树不为空，则左子树上各个节点的值 均小于 其根节点的值

2. 若右子树不为空，则右子树上各个节点的值 均大于或等于 其根节点的值

3. 左、右子树也分别具有上面两个特点

4. 【折半查找二叉判定树】_CD4356的博客-CSDN博客_二叉判定树

65.关键路径

1. ⭐从源点到终点权值最大路径a0+a4+a6+a9

2. 每条路径(入度)找最大、划掉不需要的边，有相同则保留

3. 

4. v0->v1->v4->v3->v6

v0	v1	v2	v3	v4	v5	v6
0	2(a0)	4(a2)	10(v4+a6)	7(v1+a4)	9(a2+a8)	14(v3+a9)

66.排序算法表

• 待排序序列较大时采用：堆排序，快速排序，归并排序

67.最小生成树算法

K：图相关的最小生成树（MST） - 林学徒 - 博客园 (cnblogs.com)

1. 普利姆算法(看点)：起点到其他连接最小的点为一条边，把两个连接的结点当作整体寻找下一条权值最小的顶点. O(n^2)，适合稠密图
2. 克鲁斯卡尔(看边)：找权值最小的一条边，重复查找直到所有顶点连通. O(e * loge). 适合稀疏图边数少
3. n为顶点 ，e为边

68.各排序做题方法

1. 直接插入排序(从首元素每次增加一位元素并排序)

   1. 12,53,1,43,65
      [12,53],1,43,65
      [1,12,53],43,65.....    
      

2. 选择排序(选择最大最小的于末首元素交换)

   1. 12,53,1,43,65
      [1],53,12,43,65
      [1,12],53,43,65....
      

3. 冒泡排序

   1. 12,53,1,43,65
      12,1,43,53,[65]
      12,1,43,[53,65]....
      

4. 希尔排序(根据增量分组排序，缩小增量排序)

   1. 12,53,1,43,65   gap=length/2=5/2=2
      [12],{53},[1],{43},65 //按增量从首元素分组
      1,43,12,53,65//第一趟排序后 gap/2
      1,43,12,53,65//第二趟增量为1 则相邻的元素比较大小
      1,12,43,53,65
      

5. 快速排序(交换排序)

   1. 12,53,1,43,65   //首元素为基准元素
      i           j	//j元素大于基准j--， i元素大于基准i++，其他则交换位置
      12,53,1,43,65
      i     j			//j元素交换至i
      1,53,12,43,65
        i  j			
      1,12,53,43,65 //第一趟结束，第二趟取基准两边长度一半递归执行  
      

6. 归并排序(分治法)

   1. 12,53,1,43,65 //分至每个小组只有一个元素，then合并两个组成为新一组
      [12,53],[1,43],65
      [1,12,43,53],65
      1,12,43,53,65
      

7. 基数排序(桶排序拓展)

   1. 12,53,1,43,65 // LSD(最低为数为第一个基准) MSD(最高位数为第一个基准) 以LSD为例
      //0-9个为一个桶(类似队列先进先出)
      0:
      1: 1
      2: 12
      3: 53, 43
      4:
      5: 65
      6:
      7:
      8:
      9:
      //依次从第0桶取出元素
      1,12,53,43,65 //第二趟对最低为的前一位排序
      

8. 堆排序 (完全二叉树)

   1. 堆排序详细图解（通俗易懂）_九九丸io的博客-CSDN博客_堆排序过程图解

TIP：

1.int *p

p = (int *)malloc(4);
p = (int *)malloc(sizeof(int));
//两个式子等价
//malloc的返回类型是void

2.函数指针的用法

　int add(int x, int y)
{....}
 main()
{ int  (*f)();
  f=add;
 }
赋值之后：合法的调用形式为１、add(2，3)；
２、f(2，3)；
３、（*f）（2，3）

3.scanf 和 gets

//传入字符串 good  good  study！
scanf("%s", a); //只会接收 good；不可用接受空格
gets(a); //接收good  good  study！；可以接收空格

4.指针

#include 

int main(){
    char ch[] = "iamhandsome";
    char *p = ch;
    printf("%d \n", *p);
    printf("%d \n", p);
    printf("%d \n", p + 2);
    printf("%d \n", *(p + 2));
    
    printf("%d \n", *p + 2);
}
//对应ASCII码表
105  i
6422028
6422030
109  m
107  k

5.字符串的赋值

C语言中没有字符串变量，所以用数组和指针存放字符串：

1、char   ch[10]={“abcdefgh”};                       对

2、char   ch[10]=“abcdefgh”;                         对

3、char   ch[10]={‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’};           对

4、char   *p=“abcdefgh”;                            对

5、char   *p;                                      对

p=“abcdefgh”;

6、char   ch[10];                    错了！数组名不可以赋值！

          ch=“abcdefgh”;

7、char   *p={“abcdefgh”};

6.字符串赋值的函数

//把s指针中的字符串复制到t指针中的方法
1、while（ （*t=*s）！=null ）{s++；t++；}  完整版本
2、while（ *t=*s ）{s++；t++；}           简单版本
3、while（ *t++=*s++）；                   高级版本

7.typedef

• 取别名，不会产生新的类型，也是关键词
• typedef int qq 那么 int x 就可以写成 qq x
• typedef int *qq 那么 int *x就可以写成 qq x

8.malloc

用来动态地分配内存空间

void* malloc (size_t size); size为需要分配的内存空间大小，以字节(Byte)计。

int  *p；
p = （int *）malloc（4）；
p = （int *）malloc（sizeof（int））；//以上两个等价
//malloc的返回类型是 void *

9.static

static int x; //默认值为0
int x;		 //默认值为不定值

练习知识点：

1. 若用数组名作为函数调用的实参，传递给形参的是：数组的首地址

2. 递归算法必须包括：终止条件 和 递归部分

3. 一个链表最常用的操作是再末尾插入结点和删除尾节点，选用： 带头结点的双循环链表 最节省时间

4. ⭐二叉树的 叶子结点 个数： n = n2 + 1;

   1. n为叶子结点个数， n2：度为2的结点数

5. 判别有向图中是否存在回路，可使用： 拓扑排序算法

6. 无向图的邻接矩阵是一个： 对称矩阵

7. 循环队列存储在数组A[m]中，则入队时的操作为： rear = (rear + 1) % (m + 1);

8. 快速排序在 被排序数据完全无序的情况下最易发挥其长处

9. 10000个数组元素中取几个元素，采用 简单选择排序算法 最节省时间

10. 线性表的链式存储结构，要求内存中可用存储单元的地址：连续或不连续都可以

11. ⭐树的存储形式：

• 双亲表示法
• 孩子链表表示法
• 孩子兄弟表示法

13. 连通图：若从无向图的任意一个顶点出发进行一次深度优先搜索可以访问图中所有的
    顶点

14. 浮点型变量分别为：单精度，双精度

15. 符号 ‘&’ 是 取地址运算符，&a是指：a在内存中的地址

16. 在C程序中，指针变量能够赋 地址值 或 NULL(或ˊ\0ˊ，或 0，或空值)值

17. C语言中一个字母占一个字节。但 字符串后必须跟一个结束字符’\0’，因此总共占了2个字节

• eg： “abc” 占4个字节

18.   int x;
      float y;
      scanf("%3d%f", &x, &y);
      printf("%d,%f", x,y);
      //输入 12345 789
      //输出 123,45.000000
    

19. C语言中，紧跟在关键字if后的一对圆括号里的表达式：可以是任意表达式

20. C语言中，运算对象必须是整型的运算符：%

21. C语言函数是由 函数头和函数体两部分组成其中，函数头包括：函数说明，函数名，圆括号中的形式参数

22. 结构中可设定若干个不同类型的成员

23. 结构中成员的数据类型可以是另一个已定义的结构

24. 说明一个结构体变量(struct)时，系统分配给他的内存是：各成员所需内存量的总和

25. 说明一个共用体变量(union)时，系统分配给他的内存是：成员中占内存里最大者所需的容量

26. 一个共用体变量不能同时存放其所有成员

27. C语言共用体类型变量在程序运行期间：只有一个成员驻留在内存中

28. C语言中，简单变量作为实参时，它和对应形参之间的数据传递方式是：单向值传递

29. 广义表表示法 不是树的存储形式

30. 若采用 折半查找方法，数据文件应为 有序表，且限于顺序存储结构

31. 串是一种特殊的线性表，体现在：数据元素是一个字符

32. 哈夫曼树

• 定义：

  • 当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，
    如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，
    有时也叫“赫夫曼树”或者“哈夫曼树”

• 相关名词：

  • 

• 构建原则：权重越大的结点离树根越近

33. 二叉树的性质：

• 

34. 数据的逻辑结构与数据元素本身的内容和形式无关
35. 中序序列和后序序列相同的二叉树为：空树和缺右子树的单支树
36. 对于两颗具有相同关键字集合而形状不同的二叉排序树，中序遍历后得到的关键字排列顺序相同
37. C语言的数据类型中，构造类型包括：数组、结构体、共用体、和枚举类型
38. 若一全局变量只允许本程序文件中的函数使用，则该变量需要使用的存储类别是：static
39. 系统对预处理命令(如宏替换、文件包含、条件编译)的处理时机是：运行程序时
40. 中序遍历的递归算法平均空间复杂度为：O(n)

C语言程序设计试题：

图：

1. AOV网是一种：有向无环图（有向无回路的图

2. 设有n个结点的无向图

   1. 最少n-1条边，能形成一个连通图
   2. 至少应有2n-1条边，才能确保是一个连通图
   3. 假设六个结点：11条边画法：
      1. 

3. 对于一个具有n个顶点和e条边的有向图和无向图，在其对应的邻接表中，所含边结点分别有e个和2e个

4. ⭐在一个具有n个顶点的无向完全图中，包含有n(n-1)/2条边

5. ⭐在一个具有n个顶点的有向完全图中，包含有**n(n-1)**条边

6. ⭐无向图G中有n个顶点和e条边，则其对应的邻接表中有 n 个表头结点，2e个表结点

7. 在图的邻接表中，每个结点被称为边结点，通常包含三个域：邻接点域、权域、链域

8. 

   1. 无向图，每条边都被存储了两次，所以邻接矩阵中有2e个不为零元素
   2. 由于n个顶点的邻接矩阵为n X n个元素的方阵
   3. 零元素的个数为 n^2 - 2e

9. 

   1. 删除与某个顶点V相关的所有边的过程：
      1. 先删除下标为V的顶点表节点的单链表，出边数最多为n-1，对应时间复杂度为O（n）
      2. 再扫描所以边表的结点，删除所有的顶点V的入边，对应的时间复杂度为O(e)
      3. 故总的时间复杂度为O(n+e)

10. ⭐一个连通图G中有n个顶点e条边，则其最小生成树上有 n-1 条边

11. 某有向图有n个顶点，则该有向图对应的邻接表中有 n个表头结点

12. 有n个顶点的强连通图，最多有n(n-1)条边，最少有n条边

13. 设有向图G用邻接矩阵A[n] [n]作为存储结构，则该邻接矩阵中第i行上所有元素之和等于顶点i的出度，第i列上所有元素之和等于顶点i的入度

14. ⭐设有向图G中有n个顶点e条有向边，所有顶点入度数之和为d，则 e = d

15. 设某无向图中有n个顶点e条边

    1. 该无向图中所有顶点的入度之和为：2e
    2. 所有顶点的度数之和为d，则：e = d/2

16. 有向图的邻接表中有n个表头结点，m个表结点，则图中有 m 条有向边

    1. 

17. 

    1. 对称矩阵：a[i] [j] = a[j] [i] = 1

18. 在图的邻接表中，用顺序存储结构存储表头结点的优点是：可以随机访问到任意一个顶点的简单链表

19. 设有向图G的存储结构用邻接矩阵A来表示，则A中:

    1. 第i行中所有非零元素个数之和等于顶点i的出度
    2. 第i列中所有非零元素个数之和等于顶点i的入度

20. 设某无向图中有n个顶点e条边，则建立该图邻接表的时间复杂度是：O(n+e)

21. 设某有向图中有n个顶点e条边，进行广度优先遍历，其算法得时间复杂度

    1. 若采用邻接矩阵存储：O(n^2)
    2. 若采用邻接链表存储：O(n+e)

22. 调用一次深度优先遍历可以访问到图中的所有顶点：

    1. 无向连通图，有向强连通图可以
    2. 无向的非连通图就不可能一次遍历访问到所有顶点
    3. 有向非强连通图可能对，可能不对

23. ⭐AOV网是一种 有向无回路的图。DAG图称为 有向无环图

24. 设无向图G=(V,E)中含7个顶点，则图G在任何情况下都是联通的，则至少需要的边数是:

    1. 表示边分布最浪费的最少边情况，取点数减一的完全图6*5/2=15再加一条边得结果16

25. 一个含有n个顶点的无向连通图采用邻接矩阵存储，则该矩阵一定是：对称矩阵

26. ⭐设无向连通图中有n个顶点e条边若满足e≥n，则图中一定有回路

27. ⭐对于有n个顶点的带权连通图，它的最小生成树是指图中任意一个:由n个顶点构成的极小连通子图，且边的权值之和最小

28. 对于由n个顶点e条边的有向图，求单源最短路径的迪杰斯特拉算法（Dijkstra）的时间复杂度为O(n^2)

29. 

    1. 无向图中：各顶点的度数和等于无向图边数的两倍
    2. 设剩下的都顶点都是度为1的顶点则：4 x 3 + 3 x 4 + 2 x 2 + 1 x n = 16 x 2
    3. 则n=4(度为0的顶点数量)
    4. 顶点总数=3+4+2+4 = 13

30. 一个表示工程的AOE网（有向无环图）中的关键路径：可以有多条

31. 

    1. 

32. 存储稀疏图，用邻接表比使用邻接矩阵更省空间

33. 若有向图中存在拓扑序列，则该图不存在回路

34. ⭐完全有向图一定是强连通图，且有n个顶点的完全有向图的弧数/边数为 n(n-1)

35. 在有n个顶点的有向图中，每个顶点的度最大可达:2(n-1)

36. Prim算法适合用于构造一个稠密图G的最小生成树

37. Kruskal算法适合构造一个稀疏图G的最小生成树

38. ‍♀ 无向图的邻接矩阵，第i行上的非零元素个数和第i列的非零元素个数一定相等

39. 设无向图的顶点个数为n，则该图最多有：n(n-1)/2条边

40. 设无向图的顶点个数为要保证该图在任何情况下都是连通的，则需要的边数最少是: (n-1)(n-2)/2 + 1

41. 采用邻接表存储的图的

    1. 深度优先遍历算法类似于二叉树的：先序遍历
    2. 广度优先遍历算法类似于二叉树的：层次遍历(按层遍历)

42. 有n个顶点的带权连通图，它的最小生成树是指图中任意一个：由n个顶点构成的极小连通图，且边的权值之和最小

43. 对于n个顶点e条边的有向图，采用邻接矩阵表示，求单源最短路径的Dijkstra算法的时间复杂度为：O(n^2)

44. 如果从无向图的任一顶点出发进行一次广度优先遍历即可访问所有顶点，则该图一定是：连通图

45. 含有n个顶点的连通图中的任意一条简单路径，其长度不可能超过：n-1

46. 如果某图的邻接矩阵是对角线元素均为零的上三角矩阵，则此图时：有向无环图

    1. 邻接矩阵是上三角阵无疑是有向图

47. 一个有向图的邻接表和逆邻接表的表结点个数一定相等

48. 图G的拓扑序列唯一，则其弧数不一定为n-1(n为顶点个数)

    1. 拓扑序列唯一，和边的数量，图的形状不能对等

49. n个顶点的连通图至少n-1条边，至多n(n-1)/2条边

50. ️ 如果以图中的顶点来表示活动，有向边表示活动之间的优先关系，这种用顶点表示活动的有向图为：AOV网（有向无回路）

51. n个顶点的无向连通图中至少含有n-1条边

52. 带行表的三元组表是稀疏矩阵的一种:顺序存储结构

53. 一个图(连通图)中，生成树不唯一但最小生成树唯一(边权值之和最小)

54. 具有n个顶点的图是一个环，则它有n-1棵生成树

55. DFS算法(深度优先遍历算法)的时间复杂度：O(n^2)

56. 根据邻接矩阵求深度优先遍历的结果：

    1. 

    2. 0：无连接 1：有连接

    3. 从0开始则看v0列出现的第一个1 为v1，看v1列出现的第一个1…依次类推 得结果：0 1 3 4 2 5 6

57. n个顶点e条边的图采用邻接矩阵存储，深度优先遍历算法的时间复杂度为 O(n^2) ；若采用邻接表存储时，该算法的时间复杂度为 O(n+e)

58. n个顶点e条边的图采用邻接矩阵存储，广度优先遍历算法的时间复杂度为 O(n^2) ；若采用邻接表存储，该算法的时间复杂度为 O(n+e)

59. 图的BFS(广度)生成树的树高比DFS(深度)生成树的树高小或相等

60. 具有n个顶点e条边的图的两种算法的最小生成树的时间复杂度：

    1. BFS：O(e * log2e)
    2. DFS：O(n ^ 2)

树、排序、数组

1. 在链表的结点中，数据元素所占的存储量和整个结点所占的存储量之比称作:存储密度

2. C语言标准库函数，fread(fd, buffer, n) 的功能是：

   1. 从文件fd中读取长度不超过 n个字节的数据送入buffer指向的内存区域

3. 当一个共用体声明时，编译程序自动地产生一个变量，其长度为联合中最大的变量长度的整数倍。

   1. union的存储空间先看它的成员中哪个占的空间最大,拿他与其他成员的元长度比较,如果可以整除,ok   ,否则,找第一个能被整除的数
      

4. 静态(static)类型变量的生存期贯穿于整个程序的运行期间

5. #define M(x,y,z) x*y+z
   int main(int argc, char* argv[]){
     int a=1,b=2,c=3;
   printf("%d\n", M(a+b,b+c,c+a));
     return 0;
   } 
   /**
   #define M(x,y,z) x*y+z
   扩展到: a+b*b+c+c+a
   **/
   

6. 关系模型中的三类完整性约束：

   1. 实体完整性
   2. 参照完整性
   3. 用户定义完整性

7. 对线性表，采用顺序存储的优点是：便于随机存取

8. 具有n个结点的完全二叉树的第一层为根结点，若一个结点 i 满足2i>n，则该结点没有：左子结点

9. 当调用函数时，实参是一个数组名，则向函数传递的是：数组的首地址

10. 结构化程序设计使用顺序,选择和循环三种基本控制结构，它们的共同特点是：单入口单出口

11. 关系数据库的规范化理论要求关系数据库中的关系必须满足起码的，即每个属性都是不可分解的

12. Hash算法采用开放定址法处理散列表的冲突时，其平均查找长度：高于链接法处理冲突

13. 若需要利用形参直接访问实参时，应将形参变量说明为：引用参数

14. 一颗结点数为n的二叉树，其所有结点的度的总和是 n-1

15. 对于一颗具有n个结点的二叉树，用二叉链表存储时，其指针总数为2n个，其中n-1个用于指向孩子，n+1个指针是空闲(空指针域)的

16. 对于一颗具有n个结点的二叉树从0开始进行结点的编号，并按此编号把它顺序存储到一维数组A中，即编号为0的结点存储到A[0]中，依此类推

    1. A[i]元素的左孩子元素为：2i+1
    2. 右孩子元素为：2i+2
    3. 双亲元素为：(i-1)/2

17. 线性表的散列存储中，处理冲突的常用方法有：开放地址法，链地址法

    1. 开放地址法：一旦发生冲突，就去寻找下一个空的散列地址
    2. 链地址法：将所有关键词为同义词(即哈希地址相同)的记录存储在一个单链表中，这种表为同义词子表
       1. 且在散列表中只存储所有同义词子表的头指针

18. 栈和队列的共同特点：只允许在端点处插入和删除元素

19. 用链接方式存储的队列，在进行插入运算时：头、尾指针可能都要修改

20. ⭐对n个记录的文件进行快速排序，所需要的辅助存储空间大致为：O(log2n)

21. 堆排序过程中，对任一分支节点进行筛选运算的时间复杂度为O(log2n)，整个堆排序过程的时间复杂度为O(nlog2n)

22. 一种抽象数据类型包括：数据描述和操作描述两个部分

23. 一个索引文件的索引表中，每个索引包含对应记录的索引值域和开始位置域

24. 在对m阶的B-树插入元素的过程中，每向一个结点插入一个索引项(叶子结点的索引项为关键字和空指针)后，若该结点的索引项数等于m个，则必须把它分裂为m-1个结点

25. 算法是指：解决问题的有限运算序列

26. 由两个栈共享一个向量空间的好处是：节省存储空间，降低上溢发生的机率

27. 数组data[m]作为循环队列SQ的存储空间，front为队头指针，rear为队尾指针，则执行出队操作后其头指针，front的值为：front=(front + 1)%m

28. 一个非空广义表的表头：可以是子表或原子，表尾一定是子表

29. 

    1. 设总共有结点n个 n = n0+n1+n2+n3
    2. 该树中除了根节点没有前驱以外,每个节点有且只有一个前驱,因此有n个节点的树的总边数为n-1条.
    3. 根据度的定义,总边数与度之间的关系为：n-1=0 x n0+1 x n1+2 x n2+3 x n3
    4. 联立两个方程n0=6

30. 适于对动态查找表进行高效率查找的组织结构是:归并排序

31. 不定长文件是指:记录的长度不固定

32. 数据的逻辑结构与数据的存储(存储结构)无关，是独立于计算机的

33. 已知一棵完全二叉树中共有N个结点，则该树中共有N/2 个叶子结点

34. ⭐单链表上难以实现的排序方法有:快速、堆、希尔排序

35. 多重表文件和倒排文件都归属于：多关键字文件

36. 在多重表文件中，此关键字索引的组织方式是将次关键字相同的记录链接成一个链表

37. 组成数据的基本单元是：数据元素

38. 

    1. 仅存上三角或者下三角，再加对角线
    2. ((n-10) / 2) + 10 其中：n = 10 x 10

39. 设哈夫曼树中的叶子结点总数为m，若采用二叉链表作为存储结构，则该哈夫曼树总共有 2m 个空指针域

40. 设二叉排序树中有n个结点，则在二叉排序树的平均查找长度为：O(log2n)

41. 设一颗完全二叉树中有500个结点，则该二叉树的深度为：500；若用二叉链表作为该完全二叉树的存储结构，则共有501个空指针域

    1. 满二叉树结点总数为：2^n - 1

    2. 1+2+4+8+16+32+64＋128＋245 = 500

    3. 若第九层全满, 总的节点数应为513

       所以有13个节点缺失

       所以 空指针域 244 x 2+6 x 2+1=501

42. 哈夫曼树只有度为0和2的结点，没有度为1的结点

43. 中序遍历二叉排序树中的结点可以得到一个递增的关键字序列

44. ⭐设有n个结点的完全二叉树，如果是按照从上到下，从左到右从1开始顺序编号，则第i个结点的双亲结点编号为：i/2,右孩子的编号为：2i+1

45. 在一颗二叉排序树中插入一个结点的时间复杂度：O(n)

46. 

    1. 

47. 

    1. 哈夫曼树叶子结点n， 总结点数=2 x n - 1
    2. 空指针域：n个结点的二叉树有2n的指针域，空指针域为:n+1,非空指针域为:n-1

48. 二叉链表存储并不存储权值结点，只存叶子结点。（叶子结点指针域都是空的，最后一个叶子结点的右指针也是空的）

49. 所以空指针数=叶子结点数+1

50. 数据的最小单位：数据项

51. 一个有序的单链表中有n个结点，要求插入一个新结点后是得单链表仍然保持有序，则该操作的时间复杂度为：O(n)

52. 

    1. 出栈后，逆序排列，第n个元素与第i个元素的值之间相差（n-i）
    2. 故正序1加上相差的（n-i）就是出栈时第i个元素的值
    3. 结果 = n+1-i

53. 

    1. top1 + 1 = top2

54. 一个具有n个结点的完全二叉树的深度：

    1. 结点个数和树深度的关系：2^k - 1 = n
    2. k = ⌈log2(n+1)⌉或⌊log2n⌋+1
    3. 求证：具有 n 个结点的完全二叉树的深度为…_hnjzsyjyj的专栏-CSDN博客_具有n个节点的完全二叉树的深度为

55. 时间复杂度不受数据初始状态影响而恒为O(log2n)的是：堆排序

56. 设二叉树的先序遍历序列和后序遍历序列，则该二叉树满足的条件是：任一结点无右孩子或任一结点无左孩子，但一定是高度等于其结点数

57. ⭐深度为k的完全二叉树中最少有2 ^ (k - 1)个结点，最多有(2 ^ k) - 1个结点

58. 二叉排序树上查找结点的平均时间复杂度为：O(log2n)

59. 分块查找的平均查找长度不仅与索引表的长度有关，而且与块的长度有关

60. 冒泡排序在初始序列逆序的情况下执行的交换次数最多

61. 满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树

62. 设一棵树T可以转化成二叉树BT，则二叉树BT中一定没有右子树

63. 中序遍历二叉树可以得到一个有序的序列

64. 设指针遍历p指向单链表中结点A，指针变量s指向被插入的新节点X，则进行插入操作的语句为(结点的指针域为next)：

    1. s->next = p->next;
       p->next = s
       

65. 

66. 顺序线性表中有n个数据元素，则第i个位置上插入一个数据元素需要移动表中 n + 1 - i个数据元素；删除第i个位置上的数据元素需要移动表中 n - 1个元素

67. 

68. 二叉树的第k层的结点数最多为：2^(k-1)

69. 向一颗B_树插入元素的过程中，若最终引起树根节点的分裂，则新树比原树的高度 增加1

70. ⭐有效的使用HASH查找技术，必须解决的两个问题是：构造一个好的HASH函数，确定解决冲突的方法

71. 

    1. 自堆至叶子的调整过程为筛选
    2. 从一个无序序列建堆过程就是一个反复筛选的过程
    3. 若将此序列看成是一个完全二叉树，则最后一个非终端结点是第[n/2]个元素，由此筛选只需从第[n/2]个元素开始

72. 线性表中除首尾元素之外，其他元素都仅有一个直接前驱和一个直接后继

73. 链栈相较于顺序栈而言，优点为：通常不会出现栈满的情况

74. 散列函数数值应按 同等概率 取其值域的每一个值

75. 排序方法的稳定性是指：对于关键字值相同的记录，其相对位置在排序后不发生变化

76. 稀疏矩阵的压缩存储方法一般有 三元组法和十字链表法

77. 广义表的深度指表中所含 括号的层数

78. 假设n个关键字均有相同的Hash函数值，若用线性探测再散列方法将这n个关键字映射存储到Hash表中，则共需 :n x (n-1)/2次探测

79. 一颗含有n个结点的线索二叉树中，其线索个数为：n+1

80. ⭐在一棵m阶B-树中删除一个关键字会引起合并，则该结点原有 (m/2) - 1 个关键字

81. 设森林F对应的二叉树为B，B中有m个节点，其根结点的右子树的节点个数为n，森林F中第一棵树的节点个数是：m - n

82. 一颗深度为k的平衡二叉树，其每个非叶子节点的平衡因子均为0，则该树共有 2^k - 1

83. 平衡因子都为0，表示每棵左子树的深度和每棵右子树的深度均相等,即该平衡二叉树应该是满二叉树

84. 对线性表进行折半查找时，要求线性表必须:以顺序方式存储，且节点按关键字有序排序

85. ⭐顺序线性表中有n个数据元素，则

    1. 在第i个位置上插入一个元素需要移动 n+1-i
    2. 删除表中第i个元素需要移动 n-i 个元素

86. 设指针变量p指向双向链表中结点A，指针变量s指向被插入节点x，则在结点A的后面插入结点X的操作序列为：

    1. s->left = p;
       s->right = p->right;
       p->right->left = s;
       p->right = s;
       

87. ⭐设顺序表的长度为n，则顺序查找的平均比较次数为:(n + 1)/2

88. 

89. 
    

    1. 

90. 采用递归方式对顺序表进行快速排序时，递归次数与每次划分后得到的分区处理顺序无关

91. 若某循环队列有队首指针front和队尾指针rear，在队不满时进队操作仅会改变:rear指针

92. 对有n个记录的表进行直接插入排序，在最好情况下需要比较 n-1次关键字

93. 对含有n个元素的关键字序列进行直接选择排序时，所需进行的关键字之间的比较次数为：n(n-1)/2

94. 由n个无序的元素创建一个有序单链表的算法的时间复杂度是: O(nlog2n) 或 O(n^2)

95. 顺序存储表示法(存储形式)不是m叉树(m>2)的存储形式

96. ‼️ 关于m阶B_树：

    1. m阶B_树是一颗平衡的m叉树
    2. 根结点最多含有m棵子树
    3. 根结点至少含有2棵子树
    4. 每个结点最多包含：m-1个关键字

97. 对一个线性序列进行排序，该序列采用单链表存储，最好采用直接插入排序方法

98. 当用一个数组data[0…n-1]存放栈中元素时，栈底最好设置在data[0]或data[n-1]处

99. 在一颗平衡二叉树中，每个结点的平衡因子的取值范围是: -1 ~ 1

100. 平衡因子 = 左子树深度 - 右子树深度

101. 哈希查找中：哈希表的装填因子等于填入的记录数除以哈希表的长度

102. 堆的形状是一颗完全二叉树，完全二叉树不一定是堆

103. 在有n个结点的二叉链表中

     1. 值为空的链域个数为n+1个，非空的个数为n-1个

104. 满二叉树结点数一定是奇数个

105. 顺序存储方式既能存储线性结构也能存储非线性结构

106. 二叉树第k层最多有2^(k-1)个结点

107. 二维数组是其数据元素为线性表的线性表

108. 链表**不具备**可随机访问任一节点的特点

109. 静态链表：需要分配较大空间，插入和删除不需要移动元素的线性表

110. 在一个长度为n(n>1)的单链表上，设有头和尾两个指针，执行删除单链表中的最后一个元素操作于链表的长度有关

111. 对线性表的操作只有两种，删除第一个元素，在最后一个元素的后面插入元素，则最好使用：只有表尾指针没有表头指针的循环单链表

112. 顺序存储结构的优点：存储密度大

113. n个结点的线性表的数组实现中，访问第i(1

114. 单链表增加一个头节点的目的是为了：方便运算的实现

115. 队列的基本逻辑运算：

     1. 队列初始化
     2. 入队操作
     3. 出队操作
     4. 读队头元素
     5. 判队列空操作
     6. 判队列满操作

116. 

     1. 

     2. 若栈采用顺序存储方式存…

117. 

     1. 

118. B树和B+树：

     1. 都能有效的支持随即查找
     2. 都是平衡的多叉树
     3. 都可用于文件索引结构

119. 查找效率最高的二叉排序树是：平衡二叉树

120. 直接选择排序：关键字的比较次数与记录的初始排列次序无关

121. ❔ 堆：将所有数据序列按完全二叉树从根开始放 ,
     如果所有分支都小于或者等于孩子结点关键码 ,就是小顶堆 ,反之 ,如果所有分支结点的关键码大于或者等于孩子结点关键码 ,则为大顶堆

122. N个结点的二叉排序树有多种，其中**树高最小的二叉排序树是最佳的**

     1. 二叉排序树主要用于查找
     2. 高度越小，平均查找复杂度越低

123. 在广义表的存储结构中，单元素节点与表元素结点有一个域对应不同，各自分别为：值域(data)和子表指针域(sublist)

124. 

125. 

126. **散列查找**的平均查找长度与结点个数n无关

127. 

     1. 将非零元素所在行、列、非零元素的值构成一个三元组（i，j，v） ；
        对于该题：
        每个非零元素占3*2=6个字节，共10个非零元素，需6*10 = 60 个字节；
        此外，还一般要用三个整数来存储矩阵的行数、列数和总元素个数，又需要3*2 = 6个字节；
        总共：60 + 6 = 66 个字节
        

128. 在n个结点的二叉链表中，空链域为n+1个，非空链域为n-1个

129. 在一颗m阶B树中，除根结点外，每个节点最多有m棵子树，最少有m/2棵子树

130. 在一棵m阶B-树中删除一个关键字会引起合并，则该结点原有 (m/2)-1 个关键字

131. 一颗结点个数为n的m(m>=3)次树中，其分支数是：n-1

132. 一颗深度为k的平衡二叉树，其次每个非叶子结点的平衡因子均为0，则该树共有2^k - 1个结点

133. ⭐假设有k个关键字互为同义词，若用线性探测法把这k个关键字存入哈希表中，至少要进行 k(k+1)/2 次探测

     1. 

134. 一个n x n阶的对称矩阵A，如果采用以**列优先(即以列序为主序)的压缩方式存放到一个一维数组B中，则B的容量为：n(n+1) / 2**

135. 某算法的空间复杂度为O(1),则该算法执行所需辅组空间大小与问题规模n无关

136. 直接插入排序在初始序列已基本有序的情况下，排序效率最高

137. 在C语言中，二维数组元素在内存中的存放顺序是：按行存放

138. 在C程序中，根据数据的组织形式可以分为ASCII文件和二进制文件

139. C语言可以利用指针实现函数返回多个值

140. 以#号开始的语句都是预处理语句

141. 要完全避免散列产生的堆积现象，通常采用"公共溢出区"解决冲突

142. n个元素的顺序表中查找元素

     1. 查找成功时的平均查找长度为：(n+1)/2
     2. 查找不成功是，与关键字比较次数为：n+1

143. 

     1. 

144. C语言的非空的基本数据类型包括：实型、整型、字符型

145. 由n个键值构造的二叉排序树，在等概率查找的假设下，查找成功的平均查找长度的最大值可能达到：(n+1)/2

146. 由两个栈共享一个向量空间的好处时：节省存储空间，减低上溢发生的机率

147. 适于动态查找表进行高效率查找的组织结构是：三叉排序树

148. 

     1. 

149. 二叉树在线索化后，仍不能有效解决的问题是：中序线索二叉树中求中序前驱

151. 给出不同输入序列建造二叉排序树，一定得到不同的二叉排序树

152. 

     1. 

153. 采用两类不同存储结构的字符串可分别简称为：顺序串和链串

154. 在一个长度为n的顺序表中删除第i个元素，要移动 n-i 个元素。如果在第i个元素前插入一个元素要后移 n-i+1 个元素

155. 在循环队列中，队头位置发生变化的操作是：出队

156. 设主串长为n，模式串长为m(m<=n)，则在匹配失败情况下，朴素匹配算法进行的无效位移次数为：n-m+1

157. 在一棵m阶B-树中,若在某结点中插入一个新关键字而引起该结点分裂,则此结点中原有的关键字的个数是 m-1

158. 由同一关键字集合构成的各棵二叉排序树:其形态不一定相同，平均长度也不一定相同

159. 数据的逻辑结构在计算机存储器内的表示，称为数据的**存储结构**

160. 产生冲突现象的两个关键字称为该散列函数的同义词

161. 若采用孩子兄弟链表作为树的存储结构，则树的后序遍历应采用二叉树的:中序遍历算法

162. 按排序过程中依据的原则分类，快速排序属于：交换类的排序方法

163. 散列文件也称为直接存取文件

164. 串匹配算法的本质是：子串定位

165. 若需要高效的查询多关键字文件，可以采用的文件组织方式为：倒排文件

166. 若为文件中的每个记录建立一个索引项，则建立的索引表称为：稠密索引

167. 利用直接插入排序法的思想建立一个有序线性表的时间复杂度为:O(n^2)

168. 设散列表中有 m 个存储单元，散列函数 H(key)= key % p ，则 p 最好选择：小于等于m的最大素数

169. 用邻接矩阵作为图的存储结构时，则其所占用的存储空间只与图中顶点个数有关

170. 

     1. O(n^2)
     2. O(n+e)

171. 数据结构从逻辑上划分为三种基本类型：

     1. 线性结构
     2. 树形结构
     3. 图形结构

172. 设二叉排序树的高度为n ，则在该树中查找关键字 key 最多需要比较n次

173. 设一棵 m 叉树脂的结点数为 n ，用多重链表表示其存储结构，则该树中有mn-(n-1)个空指针域

174. 具有n个结点的单链表中查找其值等于x结点是，在查找成功情况下，则平均比较 (n+1)/2 个结点

175. 树的先根遍历序列与其对应的二叉树的先序遍历序列相同

176. 对于两颗具有相同关键字集合而形状不同的二叉排序树，中序遍历后得到的关键字排列顺序相同

177. 一棵高度为 5 的理想平衡树中，最少含有2 ^ (n-1)个结点，最多含有(2 ^ n)- 1个结点。

178. 优先队列中：按优先级最高级数列先出

179. 任何简单或复杂得算法都是由 数据结构和算法这两个要素组成

自考真题

1. 

2. ❔ 用邻接矩阵表示有n个顶点和e条边的无向图，采用压缩方式存储，矩阵中零元素的个数是：n(n+1)/2 - e

3. 无向图中 所有顶点的度的和等于边数的2倍

4. 数据的逻辑结构是从逻辑关系上描述数据，它与数据元素的存储结构无关

5. 二叉树的前序遍历序列和后序遍历序列中，叶子结点之间的相对次序不变

6. 散列方法中，表示散列表装满程度的指标a称为：装填因子

7. 

   1. 将12个关键字画成完全二叉树(第一层1个，第二层2个，第三层4个，第四层5个)
   2. 第一层需要比较1次
   3. 第二层两个数，每个比较2次
   4. 第三层四个数，每个比较3次
   5. 第四层五个数，每个比较4次
   6. ASL=(1+2x2+3x4+4x5)/12 = 37/12 (答案取近似值)

8. 将一棵树T转换为一颗二叉树T1，在T1中结点A是结点B的父节点，则在T中，A可能是B的 父节点或兄弟结点

9. 哈夫曼编码：

   2. 左分支边是0，右分支边是1
   3. 编码后，1： 000，2：001， 3：01， 4：10， 5：11

算法设计题

1.在链式存储结构上建立一颗二叉排序树

/**
 * 题目：链式存储结构上建立二叉排序树
 * 二叉排序树：
 *  1.若左子树不空，则左子树上的所有结点小于根结点
 *  2.若右子树不空，则右子树上的所有节点大于根结点
 *  3.左右子树也分别为二叉排序树
 *  4.没有键值相等的结点
 */
#define n 10
typedef struct node{
    int key;
    struct node *lchild;
    struct node *rchild;
}Bitree;

void bstinsert(Bitree *bt,int key){
    //为空则设置根结点的值，左右孩子为空
	if(bt==0){
		bt=(struct node *)malloc(sizeof(struct node));
		bt->key=key;
		bt->lchild=bt->rchild=0;
	}
    //递归子树，都比根结点小的结点
    else if(bt->key>key){
		bstinsert(bt->lchild,key);	
	}
    //递归右子树，都比根结点大的结点
    else{
		bstinsert(bt->rchild,key);
	}
}

void creatbitree(Bitree *bt){
	int i;
	randomize();//这里是为了保证随机生成不同的随机数
	for(i=0;i<n;i++){
		bstinsert(bt,random(100));
	}
}

2.设计在链式存储结构上交换二叉树中所有结点左右子树的算法

    /**
     * 题目：设计在链式存储结构上交换二叉树中所有结点左右子树的算法
     * 递归思想
     * 结点不为空就交换左右子树
     */
    typedef struct node {
        int key;
        struct node *lchild;
        struct node *rchild;
    }bitree;

    void swapbitree(bitree *bt){
        //定义多一个变量用来保存子树
        bitree *p;
        if(bt == 0){
            return;
        }
        swapbitree(bt->lchild);
        swapbitree(bt->rchild);
        p = bt->lchild;
        bt->lchild = bt->rchild;
        bt->rchild = p;
    }

3.设单链表中有仅三类字符的数据元素 (大写字母、数字和其它字符 )

要求利用原单链表中结点空间设计出三个单链表的算法，使每个单链表只包含同类字符

/**
 * 设单链表中有仅三类字符的数据元素 (大写字母、数字和其它字符
 * 要求利用原单链表中结点空间设计出三个单链表的算法
 * 使每个单链表只包含同类字符
 */
typedef struct node {
    datatype data;
    struct node *next;
}iklist;

void split(iklist *head, iklist *ha,iklist *hb, iklist *hc){
    iklist *p;ha=0,hb=0,hc=0;
    for(p = head;p!=0;p=head){
        head = p->next;
        p->next = 0;
        if(p->data >= 'A' && p->data <= 'Z'){
            p->next = ha;
            ha = p;
        }else if(p->data >= '0' && p->data <= '9'){
            p->next = hb;
            hb = p;
        }else {
            p->next = hc;
            hc = p;
        }
    }
}

4.判断两个二叉树是否相同

/**
 * 判断两个二叉树是否相同
 */
typedef struct node{
    datatype data;
    struct node *lichild;
    struct node *rchild;
}bitree;

int judebitTree(bitree *bt1, bitree *bt2){
    //都为空则返回正确
    if(bt1 == 0 && bt2 == 0){
        return 1;
    }else if(bt1 == 0 || bt2 ==0 || bt1->data != bt2->data){
        return 0;
    }else {
        //递归二叉树
        return judebitTree(bt1->lichild, bt2->lichild) * 
            judebitTree(bt1->rchild, bt2->rchild);
    }
}

5.两个有序单链表的合并排序算法

/**
 * 两个有序单链表的合并排序算法
 */
typedef struct node{
    int data;
    struct node *next;
}Iklist;

void mergeIKList(Iklist *ha, Iklist *hb, Iklist *hc){
    Iklist *s=hc=0;
    while(ha != 0 && hb != 0){
        if(ha->data < hb->data){
            if(s == 0){
                hc=s=ha;
            }else {
                s->next = ha;
                s = ha;
            }
            ha = ha->next;
        }
    }
    if(ha == 0){
        s->next = hb;
    }else {
        s->next = ha;
    }
}

6.顺序表中实现二分查找

/**
 * 在顺序有序表中实现二分查找
 */
struct record{
    int key;
    int others;
};

int biSearch(struct record r[], int k){
    int low=0,mid,hight=n - 1;//n=数组长度
    while(low <= hight){
        mid = (low+hight)/2;
        if(r[mid].key == k){
            return mid+1;
        }else if(r[mid].key > k){
            hight = mid-1;
        }else {
            low = mid+1;
        }
    }
    return 0;
}

7.判断是否为二叉排序树

/**
 * 判断二叉树是否为二叉排序树
 */
int minum = -32768,flag =1;
typedef struct node{
    int key;
    struct node *lchild;
    struct node *rchild;
}bitree;

void inorder(bitree *bt){
    if(bt != 0){
        inorder(bt->lchild);
        if(minum > bt->key){
            flag = 0;
        }
        minum = bt->key;
        inorder(bt->rchild);
    }
}

8.在链式存储结构上统计二叉树中结点个数

typedef struct node{
    int key;
    struct node *lchild;
    struct node *rchild;
}bitree;

/**
 * 在链式存储结构上统计二叉树中结点个数
 */
void countNode(bitree *bt,int *count){
    if(bt != 0){
        count++;
        countNode(bt->lchild, count);
        countNode(bt->rchild, count);
    }
}

9.编写一个函数，给定一个数，输出大于它的且与它相邻的 5 位素数

//编写一个函数，给定一个数，输出大于它的且与它相邻的 5 位素数。如：输入 13，则输出 17 19 23 29 31
void prime(int num)
{
  int i, j, k;
  for (i = num + 1;; i++)
  { //从定义的整数向后依次加
    for (j = 2; j < i; j++)
    {
      if (i % j == 0)
        break; //如果i取余j==0,退出本轮循环
    }          //依次循环被除数
    if (i == j)
    {
      printf("%d ", i); //如果i=j返回i
      k++;
    }
    if(k>=5){
      break;
    }
  }
}

int main()
{
  int num;
  scanf("%d", &num);
  prime(num);
}

10.编写一个函数，输入一个正整数，输出它的各个位数的平方和

//编写一个函数，输入一个正整数，输出它的各个位数的平方和
void sqrtNum(int num)
{
  int sum = 1;  //记录平方和
  int temp = 0; //记录每位数字
  while (num)
  {
    temp = num % 10;
    sum += temp * temp;
    num /= 10;
  }
  printf("%d", sum);
}

int main()
{
  int num;
  scanf("%d", &num);
  sqrtNum(num);
}

2021广东专插本计算机真题

1.什么是数据结构？什么是数据类型

• 数据结构：计算机存储、组织数据的方式。相互之间存在一种或多种特定关系的数据元素的集合
• 数据类型：一组性质相同的值的集合以及定义在这个值集合上的一组操作的总称

2.算法有哪些特点？算法和程序的主要区别是什么？

• 算法：指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制
• 区别：
  • 一个算法可以用不同的编程语言编写出不同的代码实现
  • 算法是解决问题的步骤，程序是算法的代码实现
  • 算法依靠程序来完成功能；程序需要算法作为灵魂
  • 程序= 算法 + 数据结构

算法是若干指令的有穷序列，满足性质：

1. 零个或多个输入
2. 至少一个输出
3. 有穷性
4. 确定性
5. 可行性

3.什么是指针？什么是指针变量？它们有什么关系？

• 指针：内存单元的编号,指针就是地址 地址就是指针
• 指针变量：存放内存地址的变量
• 指针和指针变量是两个不同的概念，但通常会把指针变量简称为指针

4.什么是二叉树？请简述二叉树的五种基本形态

• 二叉树是每个节点最多有两个子树的有序树，通常子树的跟被称为作“左子树”和”右子树“
• 二叉树也是递归定义的，其节点有左右子树之分，逻辑上二叉树有五种基本形态
  • 空二叉树
  • 只有一个根结点的二叉树
  • 只有左子树
  • 只有右子树
  • 完全二叉树

模拟题

1. 计算机C语言程序：必须转换成机器语言指令才能执行
2. C语言的编译过程：编辑、编码、运行、执行
3. C语言有高级语言特性实现算法，也可以支持低层硬件驱动开发，所以称为中级语言
4. 数据的不可分割单位是：数据项
5. 基于数据的逻辑关系，逻辑结构可以划分为4个基本结构
   1. 集合结构
   2. 线性结构
   3. 树状结构
   4. 网络结构
6. 强连通图奇度顶点的个数是：素数
7. 无向图的邻接矩阵一定是对称的，有向图的邻接矩阵不一定是对称的
8. 二叉树深度遍历可采用 栈
9. 图的遍历可采用 队列
10. n个结点的联通图至少有n-1条边
11. 拓扑序列是有序序列
12. n个结点的哈夫曼树共有2n - 1个结点

2021广东专插本计算机真题

1.什么是数据结构？什么是数据类型

• 数据结构：计算机存储、组织数据的方式。相互之间存在一种或多种特定关系的数据元素的集合
• 数据类型：一组性质相同的值的集合以及定义在这个值集合上的一组操作的总称

2.算法有哪些特点？算法和程序的主要区别是什么？

• 算法：指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制
• 区别：
  • 一个算法可以用不同的编程语言编写出不同的代码实现
  • 算法是解决问题的步骤，程序是算法的代码实现
  • 算法依靠程序来完成功能；程序需要算法作为灵魂
  • 程序= 算法 + 数据结构

算法是若干指令的有穷序列，满足性质：

1. 零个或多个输入
2. 至少一个输出
3. 有穷性
4. 确定性
5. 可行性

3.什么是指针？什么是指针变量？它们有什么关系？

• 指针：内存单元的编号,指针就是地址 地址就是指针
• 指针变量：存放内存地址的变量
• 指针和指针变量是两个不同的概念，但通常会把指针变量简称为指针

4.什么是二叉树？请简述二叉树的五种基本形态

• 二叉树是每个节点最多有两个子树的有序树，通常子树的跟被称为作“左子树”和”右子树“
• 二叉树也是递归定义的，其节点有左右子树之分，逻辑上二叉树有五种基本形态
  • 空二叉树
  • 只有一个根结点的二叉树
  • 只有左子树
  • 只有右子树
  • 完全二叉树

模拟题

1. 计算机C语言程序：必须转换成机器语言指令才能执行
2. C语言的编译过程：编辑、编码、运行、执行
3. C语言有高级语言特性实现算法，也可以支持低层硬件驱动开发，所以称为中级语言
4. 数据的不可分割单位是：数据项
5. 基于数据的逻辑关系，逻辑结构可以划分为4个基本结构
   1. 集合结构
   2. 线性结构
   3. 树状结构
   4. 网络结构
6. 强连通图奇度顶点的个数是：素数
7. 无向图的邻接矩阵一定是对称的，有向图的邻接矩阵不一定是对称的
8. 二叉树深度遍历可采用 栈
9. 图的遍历可采用 队列
10. n个结点的联通图至少有n-1条边
11. 拓扑序列是有序序列
12. n个结点的哈夫曼树共有2n - 1个结点