计算机转专业复习知识点

一.C编程基础：

1.在Ｃ语言中，合法的字符常量是（ D ）。  1
A. '字'    B. "A"
C."ABC"    D.'\x41'

2.错误的叙述是（ D ）。  1
A. 一个C语言源程序可由一个或多个函数组成    
B. 若一条语句较长，也可分写在下一行上
C.C程序必须包含一个main()函数    
D.构成C语言源程序的基本单元是算术表达式

//解析：
  程序的基本构成单元是函数，算术表达式只是函数内部的一部分

3.（ A ）是关于C语言数据类型的正确叙述。  1
A. 变量必须先定义后使用    B. 不允许使用空类型
C.枚举类型不是基本类型    D.数组并不是构造类型

//解析：
A.正确。在C语言中，变量在使用前必须先被定义并选择数据类型，以便系统能够知道为这个
变量分配多少内存空间。

B. 不正确，C语言中有void类型，它可以是函数的返回值类型，用于表明该函数不返回值。


C.不正确，枚举是C语言的一种基本数据类型，用于定义在程序中只能赋予其一定范围内的值的变量。

D.不正确，数组是C语言中的一种构造类型，可以由基本类型及已定义的其他类型(包括构造类型)的数据组成。

1.C主要数据类型

C语言规定的主要数据类型：
        1.基本数据类型:整型int，实型float,double，字符型char，枚举类型enum
        2.构造数据类型：数组类型，结构体类型struct，共用体类型union
        3.指针类型
        4.空类型void。不过要注意，在 C 语言中，void 类型本身是不能被用来定义变量的。
它主要的使用场景是作为函数的返回值类型，表示该函数不返回任何值。此外，void * 类型的
指针可以指向任何类型的数据，但是不能直接用于读写数据（必须先进行类型转换）。总之，我
们不能直接定义一个void类型的变量，因为void表示空类型，没有明确的大小，计算机无法为其
分配内存。

4.main( )函数的位置（  ）。
A. 必须在自定义函数前面    B. 可以在自定义函数后面
C.必须位于程序的最前面    D.必须在自定义函数后面

//解析：
B. 可以在自定义函数后面。在C语言编程中，main()函数的位置可以是在自定义函数的
前面，也可以是在自定义函数的后面。如果main()函数位于自定义函数之后，那么你需
要在main()函数前声明自定义函数。所以选项B是正确的。

5.一个C语言源程序是由（ B ）。
  
A. 一个主程序和若干子程序组成    
B. 函数组成
C.若干过程组成    
D.若干子程序组成

//解析：
  一个C语言源程序是由 B. 函数组成 的。在C语言中，所有的逻辑代码都是以函数
的形式组织的，其中包括一个必要的主函数 main() 和其他可选的子函数。这些函数可以
是用户自定的，也可以来自C语言的标准库或其他库。

6.C源程序的调试是指对源程序进行（ C ）。  1
A. 录入与编辑    B. 查错与编译
C.查错与排错    D.连接与运行

//解析：
  C源程序的调试是指对源程序进行查错与排错 的过程。程序调试通常包含检测、定位并
修正源代码中的错误或者异常。这个过程可以通过人工的方式（比如，代码审查）或者使
用一些专门的调试工具来完成。

2.运算符的优先级

7.C语言中运算符的优先级（从高到低）：

1. 后缀运算符：
- () 
- [] 
- ->
- . 
- ++ 
- --

例如函数调用 f(x)，数组索引 a[i]，指向结构体或联合体成员的指针 p->x，直接引用结构体或联合体成员 s.x，后缀自增 a++ 和后缀自减 a--。

2. 一元运算符：
- + 
- -
- !
- ~
- ++
- --
- (类型名)
- *
- &
- sizeof

例如正 +x，负 -x，逻辑非 !x，位非 ~x，前缀自增 ++a，前缀自减 --a，类型强制转换 (int)x，解引用 *p，取址 &x 和取大小 sizeof x。

3. 乘法性质运算符：
- *
- /
- %

分别为乘法 a*b，除法 a/b，和取余（模）运算 a%b。

4. 加法性质运算符：
- + 
- -

表示加法 a+b 和减法 a-b。

5. 移位运算符：
- <<
- >>

表示左移位 a<<b 和右移位 a>>b。

6. **关系运算符:**
- <
- <=
- >
- >=

分别为小于 a<b，小于等于 a<=b，大于 a>b 和大于等于 a>=b。

7. 相等类运算符:
- ==
- !=

表示等于 a==b 和不等于 a!=b。

8. **位与运算符：** &
- 表示位与操作 a&b。

9. **位异或运算符：** ^
- 表示位异或操作 a^b。

10. **位或运算符：** |
- 表示位或操作 a|b。

11. **逻辑与运算符：** &&
- 表示逻辑与操作 a&&b。

12. **逻辑或运算符：** ||
- 表示逻辑或操作 a||b。

13. **条件运算符：** ?:
- 表示三元操作符 a?b:c。

14. 赋值运算符：
- =
- +=
- -=
- *=
- /=
- %=
- >=
- <=
- &=
- ^= 
- |=

表示简单赋值 a=b 和复合赋值如 a+=b (等价于 a=a+b) 等。

15. **逗号运算符：** `,`
- 执行一系列表达式，并返回最后一个表达式的值，如 a=3, b=4, a+b 返回 7。

8.（ A ）为合法的常量。 
 
A. 52686L    
B. E-7
C.1.2E-2.1    
D.'E12'

//解析：

A. 52686L - 这是一个带有后缀 L 的长整型常量，所以这是一个合法的常量。

B. E-7 - 这不是一个合法的常量。在科学计数法中，E 之后应跟一个数字，表示10的幂次。
这里没有数字跟在 E 后面，所以它是非法的。

C. 1.2E-2.1 - 这不是一个合法的常量。在科学计数法（浮点常量）中，E 后面应跟一个数字，
表示10的幂次，且必须为整数。这里 E 后面是一个浮点数（-2.1），所以它是非法的。

D. 'E12' - 这不是一个合法的常量。在单引号中，只允许一个字符，这里在单引号里包含了
三个字符（E12），所以不符合字符常量的定义，是非法的。

所以，唯一合法的常量是选项 A. 52686L.

3.字面量常量后缀

  后缀在编程中用于显式地改变常量的数据类型，以便它们与预期的类型匹配。后缀修饰符在各种编程语言中有不同的表示和用法，但其目的都是类似的，即明确指定一个常量的数据类型或范围。

常见的常量的后缀修饰符：

1. L 或 l：表示长整型。例如 long longVar = 1234567890L;

2. LL 或 ll：表示长长整型。这通常用于非常大的整数，例如 long long veryLongVar = 1234567890123456789LL;

3. U 或 u：表示无符号整型，例如unsigned int uInt = 123U;

4. UL 或 ul：表示无符号长整型，例如 unsigned long uLong = 1234567890UL;

5. ULL 或 ull：表示无符号长长整型，例如 unsigned long long uVeryLong = 1234567890123456789ULL;

6. F或 f：表示浮点数，例如 float pi = 3.14F;

7. D 或 d：通常用于表示双精度浮点数，例如 double pi = 3.14159D;（在大多数情况下，D/d是可选的，因为默认的浮点数类型就是double）。

9.C语言整型数据在内存中的代码是用（  ）表示的。  
A. 原码    B. 反码
C.补码    D.BCD码

//解析：
C.补码 

  在C语言（和大多数现代计算机结构）中，整型数据在内存中是以补码形式存储的。原码、反码和补码都是二进制整数的表示方法，其中补码编码最常用，因为它允许使用同一种硬件实现加法和减法运算，并且它有效地增加了可用的正整数范围。

4.数据类型在C语言中的内存表示

基本数据类型在C语言中的内存表示如下：
1.整型（int)：数据在内存中以补码表示。补码是表示有符号整数的一种常见方法，它简化了加法和减法运算的处理，并允许正数和负数的统一表示。

2. 浮点数（float和double）：浮点数遵循IEEE 754标准在内存中进行存储和管理。这个标准指定了浮点数的表示方法、舍入规则、特殊值（如正无穷大、负无穷大和非数字值）等特性。

3. 字符（char）：字符在内存中以整数形式存储，通常用ASCII码或其他编码方式（例如Unicode）表示。由于字符实际上是整数，因此它们在内存中也通常以补码形式表示。

4. 布尔值（bool）：布尔值表示真或假，通常在内存中用整数1（真）和0（假）表示。与整型和字符一样，在内存中它们也可以存储为补码。

10.Turbo C中，int型数据占用的字节数（  ）。  1
A. 由用户自己定义    B. 为2个字节
C.是任意的    D.等于所用计算机的字长

//解析：
B. 为2个字节 

  在 Turbo C 编译器中，int 类型的数据占用 2 个字节。当 Turbo C 编译器被广泛使用时，将 int 数据类型定义为占用 2 个字节的整数是常见的做法。这意味着 int 类型的数据可以表示的值范围是 -32,768 (-2^15) 到 32,767 (2^15-1)。请注意，这是特定于 Turbo C 编译器的实现细节，其他编译器和系统可能会有不同的 int 大小。

11.Turbo C中，基本数据类型存储空间长度的排列顺序是（  ）。  1
A. char<int<long  int<float<double    
B. char=int<long  int<float<double
C.char<int<long  int=float=double    
D.char=int=long  int<float<double

//解析：
B. char=int<long  int<float<double  

在 Turbo C 编译器中，**基本数据类型存储空间长度的排列顺序**是 char=int<long  int<float<double，也被称为“小端字节序”（Little-Endian Byte Order）。它的含义是，内存中的多字节数据类型（例如 int 和 float）的最低有效字节（即最靠近起始地址的字节）存储在内存中最小的地址处，而最高有效字节（即最靠近结束地址的字节）存储在最大的地址处，也就是与个人计算机上通常使用的 x86 处理器的架构相匹配。

要注意，字节序的排列方式可能会因不同的处理器架构而异。例如，某些处理器采用“大端字节序”（Big-Endian Byte Order），字节的排序顺序与小端字节序相反，即最高有效字节存储在最小的地址处。因此，在处理跨平台数据或进行网络通信等任务时，通常需要考虑本机字节序和目标字节序之间的转换。

5.printf()格式说明符，以及附加格式说明符：

表 1-1格式说明符

格式字符	功   能
d	输出带符号十进制形式整数(正数不输出符号)
o	输出无符号八进制形式整数(不输出前缀0)
x,X	输出无符号十六进制形式整数(不输出前缀 Ox)，x表示 10~15的数值用 a~f显示， X表示 10~15的数值用 A~F显示
u	输出无符号十进制形式整数
f	输出单、双精度小数形式实数(6位小数)
c	输出单个字符
c	输出一串字符串
e,E	以指数形式输出单、双精度实数(尾数含1位整数，6位小数，指数最多占3位)
g,G	以%f或%e中输出宽度较小的格式输出单、双精度实数，不输出无意义的0

表 1-2 附加格式说明符

附加说明符	功 能
m(m为正整数)	为域宽描述符，数据输出宽度为m，若实际位数多于定义的宽度，则按实际位数输出，若实际位数少于定义的宽度则补以空格或0
. n(n为正整数)	为精度描述符，对实数，n为输出的小数位数，若实际位数大于所定义的精度数，则截去超过的部分；对于字符串，表示输出前n个字符
1	表示整型按长整型量输出，例如%ld、%lx和%lo；对实型按双精度型量输出，例如%lf 和%le
h	表示按短整型量输出,例如%hd、%hx、%hdo和%hu
-	数据左对齐输出，右边填空格，无一时默认右对齐输出
+	输出符号(正号或负号)
0	表示数据不足最小输出宽度时，左补零
空格	输出值为正时冠以空格，为负时冠以负号
#	对c、s、d、u类无影响；对o类，在输出时加前缀o；对x类，在输出时加前缀0x；对 e、g 和f类当结果有小数时才给出小数点

二.算法：

1.归并排序：

void _MergeSort(int* arr, int left, int right,int* tmp)
{
	if (left >= right)//=为只有一个数，＞为区间存在
	{
		return;
	}
	
	//左右区间如果没有序，分治递归分割区间，直到最小，
	int mid = (left + right) >> 1;
	//区间被分为[left,mid] 和 [mid+1,right]
	//开始递归
	_MergeSort(arr, left, mid, tmp);
	_MergeSort(arr, mid + 1, right, tmp);

	//此时通过递归已经能保证左右子区间有序
	//开始归并
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	//归并时放入临时数组的位置从left开始
	int index = left;

	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
		{
			tmp[index] = arr[begin1];
			index++;
			begin1++;
			//这三行代码可以写成一行
			//tmp[index++] = arr[begin1++];
		}
		else
		{
			tmp[index++] = arr[begin2++];
		}
	}

	//循环结束，将还没遍历完的那个区间剩下的数拷贝下来
	while (begin1 <= end1)
	{
		tmp[index++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = arr[begin2++];
	}
	
	//将排归并完的数拷贝回原数组
	for (int i = left; i <=right ; i++)
	{
		arr[i] = tmp[i];
	}
}

void MergeSort(int* arr, int n)
{ 
	//申请一个空间用来临时存放数据
	int* tmp = (int*)malloc(sizeof(int)*n);

	//归并排序
	_MergeSort(arr, 0, n - 1, tmp);

	//释放空间
	free(tmp);
}

2.求最大公因数和最小公倍数：

    最小公倍数 =  两数乘积 / 最大公因数

    最大公因数可用辗转相除法求：

假设a > b > 0，那么a和b的最大公约数等于b和a%b的最大公约数，然后把b和a%b作为新一轮的输入。

由于这个过程会一直递减，直到a%b等于0的时候，b的值就是所要求的最大公约数。

比如：

9和6的最大公约数等于6和9%6=3的最大公约数。

由于6%3==0，所以最大公约数为3。

代码实现：

int gcd(int a,int b)
{
	if(b == 0)
	{
		return a;
	}
	else
	{
		return gcd(b,a%b);
	}
}

3.二分查找：

int search(int nums[], int size, int target) //nums是数组，size是数组的大小，target是需要查找的值
{
    int left = 0;
    int right = size - 1;	// 定义了target在左闭右闭的区间内，[left, right]
    while (left <= right) {	//当left == right时，区间[left, right]仍然有效
        int middle = left + ((right - left) / 2);//等同于 (left + right) / 2，防止溢出
        if (nums[middle] > target) {
            right = middle - 1;	//target在左区间，所以[left, middle - 1]
        } else if (nums[middle] < target) {
            left = middle + 1;	//target在右区间，所以[middle + 1, right]
        } else {	//既不在左边，也不在右边，那就是找到答案了
            return middle;
        }
    }
    //没有找到目标值
    return -1;
}

4.快速排序：

//快速排序
void quick_sort(int num[], int low, int high )
{
    int i,j,temp;
    int tmp;

    i = low;
    j = high;
    tmp = num[low];   //任命为中间分界线，左边比他小，右边比他大,通常第一个元素是基准数

    if(i > j)  //如果下标i大于下标j，函数结束运行
    {
        return;
    }

    while(i != j)
    {
        while(num[j] >= tmp && j > i)   
        {
            j--;
        }

        while(num[i] <= tmp && j > i)
        {
            i++;
        }

        if(j > i)
        {
            temp = num[j];
            num[j] = num[i];
            num[i] = temp;
        }
    }

    num[low] = num[i];
    num[i] = tmp;

    quick_sort(num,low,i-1);
    quick_sort(num,i+1,high);
}

5.判断是不是素数（质数）：

质数定义:

质数 (素数）只能被 1 或自己整除。

同时它必须是大于 1 的整数。

1 不是质数也不是合成数。

常见的质数就是：2，3，5，7，11，13，17……

// 注意：需要引入math头文件
#include <math>
 
int IsPrime(int num)
{
    if(num == 1)
    {
        return 0;
    }
    else if(num == 2)
    {
        return 1;
    }
    else
    {
	    for (int i = 2; i <= sqrt(num); i++) 
        {
		    if (num % i == 0) 
            {
                return 0;
            }
	    }
    }
	return 1;
}

6.判断是不是完全数：

完全数：又称完数、完美数或完备数，是一些特殊的自然数：它所有的真因子（即除了自身以外的约数）
的和，恰好等于它本身。

例如：自然数6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1＋2＋3＝6 
又如自然数28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1＋2＋4 + 7 + 14＝28
所以，6和28是完全数。
此外，还有496、8128也是完全数。
而对于自然数16，除去它本身16外，其余的约数相加，1＋2＋4＋8＝15，所以16不是完全数。

#include<stdio.h>
#include<math.h>
int func(int n)
{
    int sum = 0;
    for(int i = 1;i < n;i++)
    {
        if(n % i == 0)
        {
            sum += i;
        }
    }
    if(sum == n)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

7.判断a,b是不是亲密数对：

亲密数
1.定义：
  如果整数a的因子和等于整数b，整数b的因子和等于整数a，因子包括1但不包括本身，
且a不等于b，则称a，b为亲密数对。

比如，220的因子为1、2、4、5、10、11、20、22、44、55、110；
     284的因子为1、2、4、71、142。
     而220的因子和1+2+4+5+10+11+20+22+44+55+110等于284；
     284的因子和1+2+4+71+142等于220，
     并且因子包括1但不包括本身，220不等于284，所以这两数为亲密数对。

int func(int a,int b)
{
    int sum_a = 0;//a的因子和
    int sum_b = 0;//b的因子和
    for(int i = 1;i < a;i++)
    {
        if(a % i == 0)
        {
            sum_a += i;
        }
    }
    for(int j = 1;j < b;j++)
    {
        if(b % j == 0)
        {
            sum_b += j;
        }
    }
    if(sum_a == b&&sum_b == a)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

8.判断是不是水仙花数：

水仙花数

定义：
  水仙花数（Narcissistic number）也被称为超完全数字不变数、自恋数、自幂数、
阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它
的每个位上的数字的 3次幂之和等于它本身

例如：1^3 + 5^3+ 3^3 = 153

int func(int num)
{
    int bai = num / 100;
    int shi = (num / 10) % 10;
    int ge = num % 10;
    if(pow(bai,3)+pow(shi,3)+pow(ge,3) == num)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

9.二分法解方程

  二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，则它在这个区间内至少存在1个根r，即f(r)=0。

二分法的步骤为：

• 检查区间长度，如果小于给定阈值，则停止，输出区间中点(a+b)/2；否则
• 如果f(a)f(b)<0，则计算中点的值f((a+b)/2)；
• 如果f((a+b)/2)正好为0，则(a+b)/2就是要求的根；否则
• 如果f((a+b)/2)与f(a)同号，则说明根在区间[(a+b)/2,b]，令a=(a+b)/2，重复循环；
• 如果f((a+b)/2)与f(b)同号，则说明根在区间[a,(a+b)/2]，令b=(a+b)/2，重复循环。

本题目要求编写程序，计算给定3阶多项式f(x)=a3​x3+a2​x2+a1​x+a0​在给定区间[a,b]内的根。

输入格式：

输入在第1行中顺序给出多项式的4个系数a3​、a2​、a1​、a0​，在第2行中顺序给出区间端点a和b。题目保证多项式在给定区间内存在唯一单根。

输出格式：

在一行中输出该多项式在该区间内的根，精确到小数点后2位。

输入样例：

3 -1 -3 1
-0.5 0.5

输出样例：

0.33

代码：

#include<stdio.h>
#include<math.h>

double f(double x,double a3,double a2,double a1,double a0)
{
	return a3*pow(x,3) + a2*pow(x,2) +a1*pow(x,1)+a0*pow(x,0);
}
int main()
{
	double a3,a2,a1,a0,a,b,mid;
	scanf("%lf %lf %lf %lf",&a3,&a2,&a1,&a0);
	scanf("%lf %lf",&a,&b);
	while(b-a > 0.001)//只能这样算区间宽度，不然会错
	{
		mid = (a+b)/2;//只能这样求中点坐标，不然会错
		if(f(mid,a3,a2,a1,a0)== 0)
		{
			break;
		}
		else if(f(mid,a3,a2,a1,a0)*f(a,a3,a2,a1,a0) > 0)
		{
			a = mid;
		}
		else
		{
			b = mid;
		}
	}
	printf("%.2lf",mid);
	return 0;
}

总结：

        这个解方程的原理就是不断缩小区间，直到区间足够小，此时区间的中间那个x的值就是方程的近似根

三.数据结构：