复试常用算法（自用）

1.加法器与累乘器

//累加
int Addition(int n) { 
	int sum = 0;
	for (int i = 0; i <= n; i++) {
		sum += i;
	}
	return sum;
}
//累乘
int multiplication(int n) { 
	int sum = 1;
	for (int i = 1; i <= n; i++) {
		sum *= i;
	}
	return sum;
}

##2. 判断最大最小值

#include <stdio.h>
#include <limits.h>

int main() { //求输入数字的最大最小值
	int max = -INT_MAX;
	int min = INT_MAX;
	int n;
	printf("需要比较的数字个数：");
	scanf("%d", &n);
	printf("输入数字序列：");
	int arr[100];
	for (int j = 0; j < n; j++) {
		scanf("%d", &arr[j]);
	}
	for (int i = 0; i < n; i++) {
		if (arr[i] > max)
			max = arr[i];
		else if (arr[i] < min)
			min = arr[i];
	}
	printf("最小值为:%d", min);
	printf("最大值为:%d", max);
	return 0;
}

2.排序

#include <stdio.h>
void swap(int a, int b);
void Bubble_Sort(int *a, int size);
void Select_Sort(int *a, int size);
void Insert_Sort(int *a, int size);
void Binary_Insert_Sort(int *a, int size);
int Partition(int *a, int low, int high);
void Quick_Sort(int *a, int low, int high);

int main() {
	int arr[100];
	int n;
	printf("待排序序列个数：");
	scanf("%d", &n);
	printf("输入待排序序列：");
	for (int j = 0; j < n; j++) {
		scanf("%d", &arr[j]);
	}
	Quick_Sort(arr, 0, n - 1);//排序
	for (int j = 0; j < n; j++) {
		printf("%d ", arr[j]);
	}
	return 0;
}

void Select_Sort(int *a, int size) {//选择排序
	int i, j;
	for (i = 0; i < size - 1; i++) {
		int min = i;
		for (j = i + 1; j < size; j++) {
			if (a[j] < a[i])
				min = j;
		}
		if (min != i) {
			int temp = a[min];
			a[min] = a[i];
			a[i] = temp;
		}

	}
}

void Bubble_Sort(int *a, int size) {//冒泡排序

	for (int i = 0; i < size - 1; i++) {
		bool flag = false;//标记是否发生过交接
		for (int j = size - 1; j > i; j--) { //一趟冒泡排序，最小值到最底层
			if (a[j] < a[j - 1]) {
				int temp = a[j];
				a[j] = a[j - 1];
				a[j - 1] = temp;
				flag = true;
			}
		}
		if (flag == false) {
			return;
		}//此趟排序没有发生交换，证明已经有序，直接结束
	}
}

void Insert_Sort(int *a, int size) {//直接插入排序
	int j, i;
	for ( i = 1; i < size; i++) {
		if (a[i] < a[i - 1]) {
			int temp = a[i];
			for ( j = i - 1; j >= 0 && a[j] > a[i]; j--) {
				a[j + 1] = a[j];
			}
			a[j + 1] = temp;
		}
	}
}

void Binary_Insert_Sort(int *a, int size) {//折半插入排序
	int j, i;
	for ( i = 1; i < size; i++) {
		if (a[i] < a[i - 1]) {
			int temp = a[i];
			int low = 0, high = i - 1;
			while (low <= high) { //折半查找插入位置
				int mid = (low + high) / 2;
				if (a[mid] < temp)
					low = mid + 1;
				else//else里包含了值相等的情况，此时同样进入右半区间查找，保证稳定性
					high = mid - 1;
			}//最后high停在low-1的位置，high前面元素值都比a[i]大；
			for (int j = i - 1; j > high; j--) {
				a[j + 1] = a[j];
			}
			a[high + 1] = temp;
		}
	}
}
int Partition(int *a, int low, int high) {//快速排序一次划分
	int temp = a[low];//用第一个元素作为枢轴
	while (low < high) {
		while (low < high &&  a[high] > temp )
			high--;
		a[low] = a[high];//比枢轴小的移到左端
		while (low < high && a[low] <= temp )
			low++;
		a[high] = a[low];//比枢轴大的移到右端
	}
	a[low] = temp;//最终位置
	return low;
}
void Quick_Sort(int *a, int low, int high) {//快速排序
	if (low < high) {
		int pivot = Partition(a, low, high);//划分
		Quick_Sort(a, low, pivot - 1);//划分左子表
		Quick_Sort(a, pivot + 1, high);//划分右子表
	}
}

3.大小写转化

#include <stdio.h>
void toupper(char *a);
int main() {
	char a[100];
	gets(a);
	toupper(a);
	printf("%s", a);
}
void toupper(char *a) {
	int i = 0;
	while (a[i] != '\0') {
		if (a[i] >= 'a' && a[i] <= 'z') {
			a[i] -= 32;//ASCII-32
		}
		i++;
	}
}

4.判别键盘输入字符的类别

#include <stdio.h>

int main() {
	int capital_latter = 0, small_latter = 0, number = 0, blank = 0, others = 0;
	char ch;
	while ((ch = getchar()) != '\n') {
		if (ch >= 'a' && ch <= 'z') {
			small_latter++;
		} else if (ch >= 'A' && ch <= 'Z') {
			capital_latter++;
		} else if (ch >= '0' && ch <= '9') {
			number++;
		} else if (ch == ' ') {
			blank++;
		} else {
			others++;
		}
	}
	printf("capital_latter： %d 个\n", capital_latter);
	printf("small_latter： %d 个\n", small_latter);
	printf("number： %d 个\n", number);
	printf("blank： %d 个\n", blank);
	printf("others： %d 个\n", others);
	printf("\n");
	return 0;
}

5.判断闰年

#include <stdio.h>

int main() {
	int year;
	printf("请输入年份：");
	scanf("%d", &year);
	if (year % 400 == 0 || year % 4 == 0 && year != 0) {
		printf("%d是闰年", year);
	} else {
		printf("%d不是闰年", year);
	}
	return 0;
}

6.百分制成绩与等级制成绩互相转换

#include <stdio.h>
#define MAX 10
void get_grade(struct Student *p, int n);

struct Student {
	char name[MAX];
	int score;
	char grade;
};

int main() {
	struct Student stu[MAX], *p;
	int n;
	printf("请输入学生人数：");
	scanf("%d", &n);
	printf("请输入学生数据：\n");
	for (int i = 0; i < n; i++) {
		scanf("%s%d", &stu[i].name, &stu[i].score);
	}
	p = stu;
	get_grade(p, n);
	for (int i = 0; i < n; i++)
		printf("姓名：%s 分数：%d 等级：%c\n", stu[i].name, stu[i].score, stu[i].grade);
	return 0;
}

void get_grade(struct Student *p, int n) {
	for (int i = 0; i < n; i++) {
		if (p[i].score <= 100 && p[i].score >= 90)
			p[i].grade = 'A';
		else if (p[i].score < 90 && p[i].score >= 80)
			p[i].grade = 'B';
		else if (p[i].score < 80 && p[i].score >= 70)
			p[i].grade = 'C';
		else if ((p[i]).score < 70 && p[i].score >= 60)
			p[i].grade = 'D';
		else if ((p[i]).score < 60 && p[i].score >= 0)
			p[i].grade = 'E';
	}
}

7.两个数的最大公因数和最小公倍数

#include <stdio.h>

void cofactor(int a, int b) {
	int i = 1;
	//辗转相除法:用其中一个数除以另外那个数,再用除数除以得到的余数,重复这个过程,直到余数为0.
	//余数为0的等式中那个除数就是最大公因数.
	while (i != 0) {
		i = a % b;
		a = b;
		b = i;
	}
	printf("最大公因数为：%d", a);

}

void multiple(int a, int b) {
	int max = (a > b ? a : b);
	while (1) {
		if (max % a == 0 && max % b == 0)
			break;
		max++;
	}
	printf("最小共倍数为：%d", max);

}

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	cofactor(a, b);
	multiple(a, b);
	return 0;
}

8.Fibonacci数列

#include <stdio.h>

int Fibonacci(int n) {//递归实现
	if (n > 2)
		return Fibonacci(n - 1) + Fibonacci(n - 2);
	else
		return 1;
}

int Fibonacci(int n) {//循环实现
	int a, b;
	for (int i = 3; i <= n; i++) {
		int temp = a + b;
		a = b;
		b = temp;
	}
	return b;
}

int main() {
	int n;
	scanf("%d", &n);
	printf("斐波那契数列的第%d项为：%d\n", n, Fibonacci(n));
}

9.验证哥德巴赫猜想

#include <stdio.h>
int prime(int n);
void Goldbach( int n ) ;

int main() {
	int n;
	scanf("%d", &n);
	Goldbach(n);
	return 0;
}

int prime(int n) { //验证质数
	if (n <= 1) {
		return 0;
	}

	else {
		for (int i = 2; i < n; i++) {
			if (n % i == 0)
				return 0;
		}
		return 1;
	}
}

void Goldbach( int n ) { //打印所有组合
	for (int i = 1; i < n / 2; i++) {
		if (prime(i) == 1 && prime(n - i) == 1) {
			printf("%d=%d+%d\n", n, i, n - i);
		}
	}
}

10.求素数、水仙花数、完全平方数

int prime(int n);//判断质数
int narcissistic( int number );//判断水仙花数

bool IsSquare(int n);//判断完全数

int main() {
	int n;
	for (int i = 100; i < 1000; i++) {
		if (narcissistic(i) == 1)
			printf("%d\n", i);
	}
	return 0;
}

int prime(int n) { //验证质数
	if (n <= 1) {
		return 0;
	}

	else {
		for (int i = 2; i < n; i++) {
			if (n % i == 0)
				return 0;
		}
		return 1;
	}
}

int narcissistic( int number ) {//水仙花数
	int n = 0, sum = 0;
	int copy = number;
	while (number) {
		n++;
		number /= 10;
	}
	number = copy;
	for (int i = 0; i < n; i++) {
		sum += pow(number % 10, n);
		number /= 10;
	}
	if (sum == copy)
		return 1;

	return 0;
}

bool IsSquare(int n) {//完全平方数
	for (int i = 1; i < n; i++) {
		if (i *i = n) {
			return true;
		}
	}
	return false;
}

11.求定积分近似值

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

double f(double x) {
	double y = sin(x);
	return y;
}

int main() {
	int n;
	double a, b;
	double sum = 0;
	printf("请输入划分精度：");
	scanf("%d", &n);
	printf("请输入积分区间：");
	scanf("%lf %lf", &a, &b);
	double h = (a + b) / n;
	for (int i = 0; i < n; i++) {
		double f1 = f(a + h * i);//f(x)
		double f2 = f(a + h * (i + 1));//f(x+h)
		sum += h * (f1 + f2) / 2;
	}
	printf("定积分值为：%lf", sum);
	return 0;
}

12.牛顿迭代法求方程根

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

int main() {
	int a, b, c, d;
	float x, x2 = 0;
	printf("请输入系数：");
	scanf("%d %d %d %d", &a, &b, &c, &d);
	printf("请输入位置：");
	scanf("%f", &x);
	while (fabs(x - x2) >= 1e-6) {
		x = x2;
		float f1 = a * pow(x, 3) + b * pow(x, 2) + c * x + d;//f(x)
		float f2 = 3 * a * pow(x, 2) + 2 * b * x + c; //f'(x)
		x2 = x - f1 / f2;
	}
	printf("%f", x);
	return 0;
}

13.二分法求方程根

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

int a, b, c, d;

float f(float x1) {
	float n = a * pow(x1, 3) + b * pow(x1, 2) + c * x1 + d;
	return n;
}

int main() {
	float x1, x2, mid, f1, f2, f3;
	printf("请输入系数：");
	scanf("%d %d %d %d", &a, &b, &c, &d);
	printf("请输入区间：");
	scanf("%f %f", &x1, &x2);
	while ((x2 - x1) >= 0.01) {
		mid = (x2 + x1) / 2;
		f1 = f(x1);
		f2 = f(x2);
		f3 = f(mid);
		if (f1 == 0)
			break;
		else if (f1 * f3 > 0) {
			x1 = mid;
		} else if (f2 * f3 > 0) {
			x2 = mid;
		}
	}
	printf("%f", mid);
	return 0;
}

14.弦截法求方程根

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

float f(float x) {
	float n = sin(x);
	return n;
}

int main() {
	float a, b, x;
	printf("请输入区间：");
	scanf("%f %f", &a, &b);
	do {
		x = (a * f(b) - b * f(a)) / (f(b) - f(a));
		if (f(x)*f(a) > 0)
			a = x;
		else if (f(x)*f(b) > 0)
			b = x;
	} while (fabs(f(x) >= 1e-6));
	printf("%f", x);
}

15.矩阵和矩阵积

#include <stdio.h>
#include <string.h>
#define M 3
#define N 3

//求矩阵的和与积
int main() {
	int a[M][N] = {0}, b[M][N] = {0}, c[M][N] = {0}, d[M][N] = {0};
	int i, j, sum = 0, k;
	printf("请输入第一个矩阵：\n");
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	printf("请输入第二个矩阵：\n");
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			scanf("%d", &b[i][j]);
		}
	}
	//矩阵和
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			c[i][j] = a[i][j] + b[i][j];
		}
	}
	//矩阵积
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			int m = 0;
			for (k = 0; k < M; k++) {
				m += a[i][k] * b[k][j];
			}
			d[i][j] = m;
		}
	}
	printf("输出两个矩阵之和：\n");
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			printf("%d ", c[i][j]);
		}
		printf("\n");
	}
	printf("输出两个矩阵之积：\n");
	for (i = 0; i < M; i++) {
		for (j = 0; j < N; j++) {
			printf("%d ", d[i][j]);
		}
		printf("\n");
	}

}

16.统计字符中单词个数

#include <stdio.h>

int main() {
	char ch[100] = {0}, a;
	int flag = 0, count = 0;
	while ((a = getchar()) != '\n') {
		if (a == ' ') { //如果是空格字符，flag置0
			flag = 0;
		} else if (flag == 0) { //如果不是空格字符，且flag是0
			flag = 1;
			count++;
		}
	}
	printf("%d", count);
}

17.最近点对问题*

18.背包问题-0 1背包

#include <Stdio.h>
#include <math.h>
int max(int *w, int *v, int n, int m);

int main() {
	int v[10] = {0};
	int w[10] = {0};
	int n, m;
	printf("输入物品个数和背包容量:");
	scanf("%d %d", &n, &m);
	printf("输入物品重量和价值：\n");
	for (int i = 0; i < n; i++) {
		scanf("%d %d", &w[i], &v[i]);
	}
	int a = max(w, v, n, m);
	printf("%d", a);
}

int max(int *w, int *v, int n, int m) {
	int dp[10][10] = {0};
	for (int i = 1; i <= n; i++) {//i表示物品序号
		for (int j = 1; j <= m; j++) {//j表示背包容量
			if (w[i - 1] > j) { //物品重量大于当前容量,不放
				dp[i][j] = dp[i - 1][j];
			} else { //放得下，有两种选择，放与不放，取其中较大值
				dp[i][j] = fmax(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
			}
		}
	}
	return dp[n][m];
}

19.背包问题-完全背包

#include <Stdio.h>
#include <math.h>
int max(int *w, int *v, int n, int m);

int main() {
	int v[10] = {0};
	int w[10] = {0};
	int n, m;
	printf("输入物品个数和背包容量:");
	scanf("%d %d", &n, &m);
	printf("输入物品重量和价值：\n");
	for (int i = 0; i < n; i++) {
		scanf("%d %d", &w[i], &v[i]);
	}
	int a = max(w, v, n, m);
	printf("%d", a);
}

int max(int *w, int *v, int n, int m) {
	int dp[10][10] = {0};
	for (int i = 1; i <= n; i++) {//i表示物品序号
		for (int j = 1; j <= m; j++) {//j表示背包容量
			if (w[i - 1] > j) { //物品重量大于当前容量,不放
				dp[i][j] = dp[i - 1][j];
			} else { //放得下，有两种选择，放与不放，取其中较大值
				dp[i][j] = fmax(dp[i - 1][j], dp[i][j - w[i - 1]] + v[i - 1]);//放入第i个之后，还可以选择放第i个
			}
		}
	}
	return dp[n][m];
}

20.多机调度问题*

21.最长公共子序列

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

int main() {
	char text1[10] = {0};
	char text2[10] = {0};
	int dp[10][10] = {0};
	int i, j, z = 0;
	printf("请输入text1：");
	scanf("%s", text1);
	fflush(stdin);
	printf("请输入text2：");
	scanf("%s", text2);
	int n = strlen(text1);
	int m = strlen(text2);

	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (text1[i - 1] == text2[j - 1])
				dp[i][j] = dp[i - 1][j - 1] + 1;
			else
				dp[i][j] = fmax(dp[i - 1][j], dp[i][j - 1]);
		}
	}
	printf("最长公共子序列长度为：%d ", dp[n][m]);
	i = n;
	j = m;
	char c[10] = {0};
	printf("最长公共子序列为： ");
	while (i > 0 && j > 0) {
		if (text1[i - 1] == text2[j - 1]) {
			c[z++] = text1[i - 1];
			i--;
			j--;
		} else if (dp[i - 1][j] < dp[i][j - 1]) {
			j--;
		} else if (dp[i - 1][j] >= dp[i][j - 1]) {
			i--;
		}
	}
	for (i = z - 1; i >= 0; i--)
		printf("%c", c[i]);
	return 0;

}

22.子数组最大和（禁用相邻元素）

//禁用相邻元素，子数组最大和
#include <Stdio.h>
#include <math.h>
int max_add(int *a, int n);

int dp[10] = {0};

int main() {

	int a[10] = {0};
	int n;
	printf("数字个数为：");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	printf("最大和为：%d", max_add(a, n));
	return 0;
}

int max_add(int *a, int n) {
	dp[0] = fmax(a[0], 0);
	dp[1] = fmax(a[0], a[1]);
	for (int i = 2; i < n; i++) {
		dp[i] = fmax(dp[i - 1], a[i] + dp[i - 2]);//（不选第i个，选第i个）
	}
	return dp[n - 1];
}

23.连续最大子数组和

//最大连续子数组和
#include <Stdio.h>
#include <math.h>
int max_add(int *a, int n);

int dp[10] = {0};

int main() {

	int a[10] = {0};
	int n;
	printf("数字个数为：");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	dp[0] = a[0];
	printf("最大和为：%d", max_add(a, n));
	return 0;
}

int max_add(int *a, int n) {
	int max = a[0];
	for (int i = 1; i < n; i++) {
		if (dp[i - 1] < 0)
			dp[i] = a[i];
		else
			dp[i] = dp[i - 1] + a[i];
		max = max > dp[i] ? max : dp[i];
	}
	return max;
}

24.连续子数组最大乘积

//最大连续子数组乘积
#include <Stdio.h>
#include <math.h>
int maxProduct(int *a, int n);

int min_number(int a, int b, int c) {
	int min = 0;
	if (a < b)
		min = a;
	else
		min = b;
	return min < c ? min : c;
}

int max_number(int a, int b, int c) {
	int max = 0;
	if (a > b)
		max = a;
	else
		max = b;
	return max > c ? max : c;
}

int main() {

	int a[10] = {0};
	int n;
	printf("数字个数为：");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	printf("最大和为：%d", maxProduct(a, n));
	return 0;
}

int maxProduct(int *a, int n) {
	int dpmax[n], dpmin[n];
	dpmax[0] = a[0];
	dpmin[0] = a[0];
	int max = a[0];
	for (int i = 1; i < n; i++) {
		dpmax[i] = max_number(a[i], dpmax[i - 1] * a[i], dpmin[i - 1] * a[i]);
		dpmin[i] = min_number(a[i], dpmax[i - 1] * a[i], dpmin[i - 1] * a[i]);
		max = dpmax[i] > max ? dpmax[i] : max;
	}
	return max;
}

25.关于数组和指针的知识点

int *p ；//p为int *型的变量，p用于存放int类型变量的地址
int a=2;
p=&a；//&：取出变量a的地址

二维数组

a[2]+3 === a[2][3]的首地址// 访问内容为*（a[2]+3）
*(a[2]+3) ====  a[2][3]
*(a+2) === a[2]
*(*(a+i)+j)=*(a[ i ]+j) = a[ i ][ j ]

a[ ][ ]可以理解为二维的 " a[ ] " 就是一维数组a[ ]的数组名a,因为" a “其实是保持了数组a[ ]的首地址，所以二维中” a[ ] "是指向列数组的指针

**a与*a都相当于&a[0][0]
但看待数组的方式不同，a指向数组首地址，但看待内部元素都为一维数组，a认为指向每个元素都是整数的一维数组，a+1跳到下一个一维数组，a+1跳到一维数组的第二个元素

int a[3][4];
int *p=a; //编译错误，int *p是指向一个整型变量，也就是四个字节，而a看待元素是一个一维数组，包含16个字节

int a[3][4];
int *p=a[0];//a[0]为指向第0列一维数组的首地址
int *p=&a[0][0];

/*以一维数组的方式看待二维数组*/
int a[3][4];
int *p = &a[0][0];//认为p指向共有个元素的一维数组

for (int i = 0; i < 3; i++) {
	for (int j = 0; j < 4; j++) {
		*(p++) = i + j;
	}
}
/*以二维数组的方式看待*/
int a[3][4];
int (*p)[4] = a;//p为指针，指向包含4个整数的一维数组

for (int i = 0; i < 3; i++) {
	for (int j = 0; j < 4; j++) {
		*(*(p + i) + j) = i + j;
	}
}

//[]优先级大于*
//认为是有三个元素的一维数组，内部存储字符串常量的首地址
char *str[3]={"ACS","BSC","CCS"}

**int *p ：一级指针，表示p所指向的地址里面存放的是一个int类型的值
int **p ：二级指针，表示p所指向的地址里面存放的是一个指向int类型的指针（即p指向的地址里面存放的是一个指向int的一级指针）
例如：
int i=10; //定义了一个整型变量
int *p=&i; //定义了一个指针指向这个变量
int p1=&p; //定义了一个二级指针指向p指针

19年A卷

#include <stdio.h>
float *search(float (*p)[4], int n);

int main() {
	float s[][4] = {//二维数组
		{60, 70, 80, 90},
		{89, 83, 67, 50},
		{43, 78, 97, 66},
		{65, 74, 92, 87}
	};
	float *p;
	int i, j;
	for (i = 0; i < 4; i++) {
		p = search(s + i, 4);//s+i遍历每行数组
		if (p == *(s + i)) {//*(s+i)取每行数组的首地址
			printf("No. %d scores:\n", i);
			for (j = 0; j < 4; j++)
				printf("%5.2f ", *(p + j));
			printf("\n");
		}
	}
}

float *search(float (*p)[4], int n) {//传入的是指向一维数组的指针 (*p)[4]类比a[4],*p === a
	float *pt = *(p + 1);//*(p+1)取p下一行的数组首地址
	int i;
	for (i = 0; i < n; i++)
		if (*(*p + i) < 60)//*p+i === a+i(一维) 即*(a+i),取第i个位置的值
			pt = *p;
	return (pt);
}

printf与scanf用到的格式附加字符

/*printf*/
	printf("%5d\n", -12); //5表示域宽
	printf("%-5d A\n", 12); //负号表示向左对齐
	printf("%7.2lf\n", 12.345); //输出字符宽度为7，小数点后两位
	printf("%7.0lf\n", 12.345); //不输出小数位，等同%7.lf
	printf("%.5lf\n", 12.345); //输出小数点后五位
	printf("%11lf\n", 12.345); //lf小数点后占六位，一共占11位
	printf("%lf\n", 12.345);//lf小数点后占六位,%f同样
	printf("%1.2f\n", 12.345);//输出结果为12.35，因为1表示至少一个字节，不够用零补
/*----------------------------------------------------------------------------*/
/*scanf*/
#include <stdio.h>
int main() {
	int a;
	scanf("%5d", &a);//前五位赋给a
	printf("%d\n", a);
	char ch;
	while ((ch = getchar()) != '\n') {
		putchar(ch);
		printf("\n");
	}
	return 0;
}
scanf("%-5d",&a);//不能使用-进行左对齐
scanf("%7.2d",&a);//不能使用7.2对输入进行限定

static

1.静态局部变量在定义的时候赋初值，不会随着函数调用结束后释放其储存单元，在下一次函数调用时，使用上一次的值
2.静态局部变量同样保留局部变量特性，无法在函数外调用
3.但可以使用指针，访问存储地址，间接在函数外调用
4.静态声明的变量，声明时的赋值仅在，声明的首次被执行

#include <stdio.h>
int *p;

void f(void) {
	int i = 10;
	static int j;//静态局部变量默认初值为零
	printf("%d,%d\n", i++, j++);
	p = &j;
}
int main() {
	f();
	f();
	f();
	printf("%d", *p);
	return 0;
}

const

用const修饰变量时，一定要给变脸初始化，否则之后就不能再进行赋值了

1. 指向const 变量的指针：const修饰的变量，只能由const类型的指针去指向
   const位置必须在*左边

const int x;
const int *p=&a;//或者 int const
int *p =&a//不行

2. 被const修饰的指针：指针指向的地址不能被改变，但地址对应元素值可以改变

int a=10;
int *const pa=&a;
int b=1;
a=20;//可以
pa=&b;//不可以

extern

在文本内扩展一个全局变量的作用域，extern只修饰全局变量
不能同时申明和定义

#include <stdio.h>
extern int a;
int main() {
	printf("%d", a);
	return 0;
}
int a = 10;

union

1.使用联合体定义变量，所有成员公用一块内存，所有成员的地址都相同
联合体的大小是最大的成员大小
同一时刻只有一个成员的值是有效的

常用函数

计算平方根：
double sqrt(double x)

取整：
double ceil(double x)

求最大最小值：
fmax(a,b)
fmin(a,b)

求绝对值：
int abs(int a) //在头文件<stdlib.h>中
fabs(a)输出是double类型
清空键盘缓冲区
fflush(stdin)

strcpy(a,b)

**char *strncpy(char dest, const char src, size_tn);
功能: 把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含’\0’。
参数:
dest：目的字符串首地址
src：源字符首地址
n：指定需要拷贝字符串个数
返回值:
成功：返回dest字符串的首地址
失败：NULL

**char *strcat(char dest, const char src);
功能: 将src字符串连接到dest的尾部，‘\0’也会追加过去
返回值:
成功：成功：返回dest字符串的首地址
失败：NULL

**char *strncat(char dest, const char src, size_tn);
功能: 将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去
参数:
dest：目的字符串首地址
src：源字符首地址
n：指定需要追加字符串个数
返回值:
成功：成功：返回dest字符串的首地址
失败：NULL

文件操作

#include <stdio.h>
#include <stdlib.h>

int main() {
	char c;
	char str[100];
	FILE *fp;//定义文件类型指针
	/*打开文件fopen(地址，"操作方式")*/
	fp = fopen("D:/example.txt", "r"); //r读文件，文件不存在时不会自动创建
	fp = fopen("D:/example.txt", "w");//w写文件，文件不存在时自动创建在路径下
	if (fp == NULL) {
		printf("文件打开失败");
		exit(0);//关闭文件;
	}

	/*-------写文件--------*/

	fputc(char c,FILE *p)写入单个字符
	while ((c = getchar()) != '\n') {
		fputc(c, fp); //将字符写入文件
	}
	fputs(str,fp)str所指的字符串写入fp所指的文件，成功返回0.否则非0
	gets(str);
	fputs(str, fp);
//  fprintf(fp,"weqwdw");

	/*-------读文件---------*/

	fgetc(fp)读单个字符
	while (c = fgetc(fp) != EOF) {
		putchar(c);
	}
	fgets(str,n,fp)从fp所指的文件中读取长度为n-1的文件存放在字符数组str中
	while (fgets(str, 20, fp) != 0) {
		puts(str);
	}
	fclose(fp);//关闭文件
	return 0;
}

变量类型

%d=int,

%ld=long,

%lld=long long;

真题易错点备注

1.代码阅读题都是有特定功能的，多分析找规律
2.改错题
==与=
结尾return 0
程序开头调用库函数的语句
库函数的大小写
调用库函数记得写头文件
#define分开定义
注意函数声明位置
字符数组a[ 字符串长度 ] 为最后一个
字符结束符不是0是’ \0 ’
字符串比大小，每次做判断都要带上指针是否为0
填空题注意scanf的输入是，间隔还是空格

3.2018年 A卷

**while(p2++=p1++)
同B卷

题有点问题，复制字符串时，原字符串小于目标字符串，会越界

include <stdio.h>
void fun(char *f,char *t)
{ 　for(;*f!=’\0’;f++,t++)
      　*t=*f;
    *t=’\0’;
}
void main(void)
{ 　char a[]="1234567890!",b[]="ABCDEFGH.";
    fun(a,b);
    printf("%20s%20s\n",a,b);
}

汉诺塔

void move(char a, char b);
void h(int n, char x, char y, char z);

int main() {
	h(4, 'A', 'B', 'C');
	return 0;

	return 0;
}

void move(char a, char b) {
	printf("从 %c 柱 往 %c柱 移动一个圆盘\n", a, b);
}
void h(int n, char x, char y, char z) {
	if (n == 2) {
		move(x, y);
		move(x, z);
		move(y, z);
	} else {
		h(n - 1, x, z, y);
		move(x, z);
		h(n - 1, y, x, z);
	}
}

螺旋矩阵

#include <stdio.h>
int main() {
	int p[10][10] = {0};
	int startx = 0, starty = 0, set = 1;
	int count = 1, n;
	scanf("%d", &n);
	int loop = n / 2;
	int i, j;
	while (loop--) {
		i = startx, j = starty;
		for (j = starty; j < n - set; j++)
			p[i][j] = count++;
		for (i = starty; i < n - set; i++)
			p[i][j] = count++;
		for (; j > starty; j--)
			p[i][j] = count++;
		for (; i > startx; i--)
			p[i][j] = count++;
		startx++;
		starty++;
		set++;
	}
	if (n % 2 != 0)
		p[n / 2][n / 2] = count;
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			printf("%3d", p[i][j]);
		}
		printf("\n");
	}

	return 0;
}

交换字母
4.递归程序先写出口
5.编程实例问题，用实例推导，模型多半是考纲要求的算法
6.do{}while(x>0);结束条件是x<=0,与while相反
7.指针表示数组a[],不能对a直接加减操作，需要新赋值 int *q=a；再对q进行操作
8.整型和浮点型做运算，转换为浮点型
9. 与 ++ 的优先级是一样的，根据编译原理应当遵守靠右的规则，所以 *p++ = *(p++)
10.写输出结果注意开头的换行符
11.\t 算四个字符

2017年 卷A
k=k*10+c-‘0’;
字符和字符相减的本质就是ASCII码的计算
用%d打印出来的结果是对应的ASCII码值；所以单个字符减去‘0’，用于字符转数字的时候 (如：‘8’ - ‘0’ 的计算结果就是8)