计算机转专业复习知识点

一.C编程基础:

1.在C语言中,合法的字符常量是( 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语言中的一种构造类型,可以由基本类型及已定义的其他类型(包括构造类型)的数据组成。

涉及知识点: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源程序的调试是指对源程序进行查错与排错 的过程。程序调试通常包含检测、定位并
修正源代码中的错误或者异常。这个过程可以通过人工的方式(比如,代码审查)或者使
用一些专门的调试工具来完成。

涉及知识点:运算符的优先级

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。

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

分别为小于 ab 和大于等于 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.

涉及知识点:字面量常量后缀

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

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

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

涉及知识点:数据类型在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

二.算法:

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 
 
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
#include
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;
    }
}


 

三.数据结构:

你可能感兴趣的:(C语言学习难点整理,前端,javascript,数据库)