C语言基础
字节大小
char：1 字节
unsigned char：1 字节
short：2 字节
unsigned short：2 字节
int：通常为 4 字节（32 位平台）或 8 字节（64 位平台）
unsigned int：通常为 4 字节（32 位平台）或 8 字节（64 位平台）
long：通常为 4 字节（32 位平台）或 8 字节（64 位平台）
unsigned long：通常为 4 字节（32 位平台）或 8 字节（64 位平台）
long long：8 字节
unsigned long long：8 字节
float：4 字节
double：8 字节
long double：通常为 8 字节（32 位平台）或 16 字节（64 位平台）
"i love you"字符串C语言中占多少字节
C语言字符串是字符数组表示，并且结尾用\0
"i love you"={'i',' ','l','o','v','e',' ','y','o','u','\0'}
11
字节
变量
变量名只能由字母、数字和下划线组成，且必须以字母或下划线开头，不能用特殊字符
自增
int a=1;
int b=++a; //a先加1 a=2 在赋值给b=2
int c=a++; //先赋值给c c=1,a在自增1；a=2
变量后先加
循环
for(开始；判定条件；循环结束执行)
运算符
运算符表达式：（表达式有几个）一目、二目、三目
三目运算符：?:
逗号
int a;
printf("%d",(a=2*5,a*4,a+3));
在这段代码中，使用了逗号运算符。逗号运算符会从左到右依次计算每个表达式，并返回最右侧表达式的值。
首先，a=2*5 将 a 赋值为 10。
然后，a*4 计算得到 40，但这个值并没有被赋给任何变量，因此它会被忽略。
最后，a+3 计算得到 13，这是逗号运算符返回的值。
因此，printf("%d",(a=2*5,a*4,a+3)); 会输出 13。
逻辑运算符
逻辑运算符的优先级从高到低为：NOT（!） > AND（&&） > OR（||）
&& 有一个为真就是真，前面为真不需要判断后面直接返回真
||全真为真，前面为假直接返回假
int x,y,z,t;
x=y=z=1;
t=++x || ++y && ++z;
printf("%d,%d,%d,%d",x,y,z,t);
++x 将 x 自增 1，然后返回 x 的值，所以 ++x 的值为2，然后 t = ++x || ++y && ++z，因为 || 运算符具有短路特性，当 ++x 的值为真（非0）时，后面的 ++y && ++z 将不再执行，直接返回 ++x 的结果，所以 y 和 z 的值没有改变，仍然为1。而 t 的值就是 ++x 的结果，也就是2。所以最后的输出结果为 2,1,1,1。
普通函数
isspace是C语言中的一个函数，用于检查给定的字符是否是空白字符。
C语言程序的基本单位是函数。一个C语言程序可以由一个或多个函数组成，其中必须有一个名为main的函数，作为程序的入口点。
指针函数
看后面，就是一个函数
返回函数结果的地址
定义：int *f()
#include <stdio.h>
int *f(){
static int x = 10; //全局使用
return &x; //返回x的地址
}
int main() {
int *r = f(); //接受返回地址
printf("%d\n",*r); //打印地址对应的值
return 0;
}
函数指针
看后面就是一个指针 ；一个指向函数的指针；在内存空间中存放的是函数的地址；
int add(int a,int b){
return a+b;
}
int main() {
int (*r)(int a,int b) = &add; //函数指针接受函数地址
int out = r(2,3); //调用函数
printf("%d\n",out);
return 0;
}
输出与输入
格式化输出
int x=10,y=3;
printf("%d\n",x%y,x/y);
输出：1
printf函数中，格式化字符串"%d\n"只对应一个输出，即x%y的结果
int a=3366;
printf("│%-08d│",a);
这段代码的目的是打印整数 a，值为 3366，在一个格式化的字符串中，字符串的格式为 “│ %-08d │”。让我们分析一下这个格式化字符串：
│是一个字面字符，它会被直接打印出来。%是一个格式说明符的开始。-表示左对齐。0表示如果数字的位数少于指定的宽度，那么不足的部分会用0填充。8表示数字的宽度为8位。d表示打印一个整数。
所以，这段代码会打印出 │33660000│。整数 a（3366）左对齐，并在右侧用0填充，以确保总共有8位数字。
int x;
x = printf("I am c program\n");
printf("x=%d", x);
首先打印字符串 “I am c program\n”，然后打印变量 x 的值。变量 x 的值就是 printf 函数返回的值，也就是打印的字符数（不包括最后的 ‘\0’ 字符）。
打印与++
#include <stdio.h>
//合并方法
int main() {
int a = 1;
printf("%d ",a++);//在前先打印，a在+1；
return 0;
}
1
#include <stdio.h>
//合并方法
int main() {
int a = 1;
printf("%d ",++a);//a先+1，后先打印；
return 0;
}
2
数组
int arr[10] = {1,2,3,4,5,6,7,8,9,10,};
//c语言数组名是第一个元素的地址
int *p = arr;
int *p1 = arr+1;//数组第二个元素的地址
int *p2 = arr++;//不允许，编译报错
printf("%d",*p);
return 0;
字符串
定义字符串
char *str1 = "Hello, World 1!";
char str2[] = "Hello, World 2!";
printf("%s\n",str1);
printf("%s\n",str2);
文件读写
C语言操作文件的标准库是stdio.h库，这个库中包含了用于文件操作的函数，例如：
- fopen()：打开文件；
- fclose()：关闭文件；
- fgetc()：从文件中读取一个字符；
- fgets()：从文件中读取一行；
- fprintf()：将格式化的数据写入文件；
- fscanf()：从文件中读取格式化的数据。
FILE *fp; // 文件指针
char ch; // 读取的字符
// 打开文件，如果文件不存在则创建新文件
fp = fopen("./study.txt", "w+");
// 向文件中写入数据
fprintf(fp, "Hello, world!\n");
// 向文件中写入数据
fputs("This is testing for fputs...\n", fp);
// 将文件指针移到文件开头
fseek(fp, 0, SEEK_SET);
// 从文件中读取数据并输出到控制台
while ((ch = fgetc(fp)) != EOF) {
putchar(ch);
}
// 关闭文件
fclose(fp);
fprintf() 和 fputs() 都是用于向文件中写入数据的 C 语言标准库函数，但它们有一些区别。
区别一：参数不同
fprintf() 函数需要指定格式化字符串以及要写入的数据，可以写入多种类型的数据，并且可以按照指定的格式进行输出。而 fputs() 函数只能写入字符串数据，不能写入其他类型的数据。
区别二：返回值不同
fprintf() 函数返回写入的字符数，如果发生错误则返回负值。而 fputs() 函数返回非负数表示成功，返回 EOF 表示失败。
区别三：功能不同
fprintf() 函数可以将多种类型的数据按照指定的格式写入文件中，可以实现更加复杂的输出操作。而 fputs() 函数只能将字符串写入文件中，功能相对较为简单。
综上所述，fprintf() 函数更加灵活和强大，可以实现更加复杂的输出操作，而 fputs() 函数则适用于简单的字符串写入操作。
fgetc() 是一个 C 语言标准库函数，用于从指定的文件中读取一个字符。
putchar() 函数会将 ch 字符输出到标准输出设备上，并返回输出的字符。如果输出失败，则返回 EOF。
算法
数组合并
两个有序数组合并一个有序数组
#include <stdio.h>
//合并方法
int main() {
int a[] = {1,3,5,7,9};
int asize= sizeof(a)/ sizeof(a[0]);
int b[] = {2,4,6,8,10};
int bsize= sizeof(b)/ sizeof(b[0]);
int r[] ={0,0,0,0,0,0,0,0,0,0};
int rsize=asize+bsize;
//合并ab到
int i=0,j=0,l=0;
while(i<=asize&&j<=bsize){
if(a[i]<=b[j]){
r[l]=a[i];
i=i+1;
}else{
r[l]=b[j];
j=j+1;
}
l=l+1;
}
for(int i=0;i<rsize;i++){
printf("%d ",r[i]);
}
return 0;
}
动态规划
未知的问题用已知的解决
定义dp数组，判断数组里面是否有，有就取，没有就放在数组
斐波那契数列
int n =10;
int dp[n+1];
dp[0]=0;
dp[1]=1;
int l = sizeof(dp)/sizeof (dp[0]);
for (int j = 2; j <=l ; ++j) {
dp[j]=dp[j-1]+dp[j-2];
}
for (int i = 0; i < l; ++i) {
printf("%d ",dp[i]);
}
printf("%d ",dp[n-1]);
走楼梯
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
p[i] = dp[i - 1] + dp[i - 2];
}
最长连续递增子序列
#include <stdio.h>
int max(int a,int b){
if(a>b){
return a;
}else{
return b;
}
}
int main() {
int arr[] = {3,2,5,7,1,4,10,8,9};
int len=sizeof(arr)/ sizeof(arr[0]);
int dp[len]; //定义dp数组
for (int i = 0; i < len; ++i) { //初始化
dp[i]=1;
};
for (int i = 0; i < len; ++i) {
int temp = arr[i];//i位置上的元素
for (int j = i; j >0 ; j--) {
if(arr[j]<temp && i==j+1){ //在i之前找到比这个小,并且是连续的
dp[i]=dp[j]+1; //以i位置结尾的最长递增子序列的长度是j的加1（i本身）
break;
}
}
}
int result = 1;
for (int i = 0; i < len; ++i) { //初始化
result=max(result,dp[i]);
};
printf("最长递增子序列的长度:%d",result);
return 0;
}
贪心
最优解决:程序通过贪心算法计算出需要使用多少个硬币找零，收银员总是先给最大的硬币
也就是说要找的零钱张数最少
#include <stdio.h>
int found(int a[],int mon,int len,int dp[]){
//要找给顾客的钱为0；就退出循环
if(mon == 0){
return 0;
}else{
for (int i = 0; i < len; ++i) {
if(a[i]>=mon){
//先找最大
dp[i-1]=mon/a[i-1];
mon=mon%a[i-1];
len=i;
break;
}
}
return found(a,mon,len,dp);
}
}
int main() {
//若干零钱
int arr[] = {1,2,5,10,20,50,100};
int mon = 37;//实际要给顾客找零
int len = sizeof(arr)/ sizeof(arr[0]);
int dp[len];//对应零钱找的张数
for(int i=0;i<len;i++){
dp[i]=0;
}
found(arr,mon,len,dp);
for(int i=0;i<len;i++){
printf("%d张%d\n",dp[i],arr[i]);
}
return 0;
}
背包
01背包
#include <stdio.h>
int max(int a, int b) {
return a > b ? a : b;
}
int knapsack(int w[], int v[], int n, int W) {
int i, j;
//构建二维数组：行放入物品种类0-n号物品种类，列是背包对应的重量，ij是背包对应的最大价值
int dp[n+1][W+1];
// 初始化dp数组--背包重量为0，其最大价值为0；背包种类为0；其最大价值为0
for (i = 0; i <= n; i++) {
for (j = 0; j <= W; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else {
dp[i][j] = -1;
}
}
}
// 动态规划求解
for (i = 1; i <= n; i++) {
for (j = 1; j <= W; j++) {
if (j < w[i-1]) {//当前背包重量小于物品重量
dp[i][j] = dp[i-1][j]; //背包最大价值是背包重量-1对应的最大价值
} else {
//当前背包重量可以放该物品
//不放，背包最大价值还是当前物品重量-1对应的价值
//放，背包最大价值是当前放入物品重量对应的价值+没放之前背包对应的最大价值
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1]);
}
}
}
return dp[n][W];
}
int main() {
int w[] = {2, 1, 3}; // 物品的重量
int v[] = {4, 2, 3}; // 物品的价值
int W = 5; // 背包的总重量
int n = sizeof(w) / sizeof(w[0]); // 物品的数量
int max_value = knapsack(w, v, n, W); // 求最大价值
printf("最大价值为：%d\n", max_value);
return 0;
}
回溯
DFS 递归判断迷宫有出路没有
#include <stdio.h>
#define M 5
#define N 5
//迷宫出口
int a=3;int b=4;
//迷宫
//0是没有访问过
//-1墙
//2访问过
int maze[M][N] = {
{0, 0, 0, 0, 0},
{0, -1, -1, 0, -1},
{0, -1, 0, 0, -1},
{0, -1, -1, -1, -1},
{-1, 0, 0, 0, 0}
};
//找出路
int find_path(int m,int n){
//当前是不是目标,是：返回找到出口
if(m==a && n==b){
maze[m][n]=2;
return 1;
}
//刚开始一定可以进去；标记走过
maze[m][n]=2;
//在迷宫内并且可以走
//上
if(0<=m-1&&m-1<=M&&maze[m-1][n]==0){
return find_path(m-1,n);
}
//右
else if(0<=n+1&&n+1<=M&&maze[m][n+1]==0){
return find_path(m,n+1);
}
//下
else if(0<=m+1&&m+1<=M&&maze[m+1][n]==0){
return find_path(m+1,n);
}
//左
else if(0<=n-1&&n-1<=M&&maze[m][n-1]==0){
return find_path(m,n-1);
}else {
return 0;
}
}
int main() {
if(find_path(0,0)){
printf("有出路");
}else{
printf("没有出路");
}
//找出路
}
BFS长草问题–BFS借助队列
【问题描述】
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，小块空地都将变为有草的小块。请告诉小明，k 个月后空地上哪些地方有草。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
接下来包含一个整数 k。
【输出格式】
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
【样例输入】
4 5
.g...
.....
..g..
.....
2
【样例输出】
gggg.
gggg.
ggggg
.ggg.
#include<stdio.h>
#include <stdlib.h>
#define M 6
#define N 6
// 定义链表节点结构体
typedef struct node {
int data;
struct node* next;
} Node;
// 定义队列结构体
typedef struct queue {
Node* front; // 队头指针
Node* rear; // 队尾指针
int size; // 队列长度
} Queue;
// 初始化队列
void initQueue(Queue* q) {
q->front = NULL;
q->rear = NULL;
q->size = 0;
}
// 判断队列是否为空
int isEmpty(Queue* q) {
return q->front == NULL;
}
// 获取队列长度
int getLength(Queue* q) {
return q->size;
}
// 入队操作
void enqueue(Queue* q, int data) {
Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点
newNode->data = data;
newNode->next = NULL;
if (isEmpty(q)) { // 如果队列为空，队头和队尾都指向新节点
q->front = newNode;
} else { // 否则，将新节点插入到队尾，并更新队尾指针
q->rear->next = newNode;
}
q->rear = newNode; // 更新队尾指针
q->size++; // 队列长度加1
}
// 出队操作
int dequeue(Queue* q) {
if (isEmpty(q)) { // 如果队列为空，返回错误码-1
return -1;
}
int data = q->front->data; // 取出队头节点的数据
Node* temp = q->front; // 用临时变量保存队头节点地址
q->front = q->front->next; // 将队头指针指向下一个节点
if (q->front == NULL) { // 如果队头指针为空，说明队列已空，将队尾指针也置为空
q->rear = NULL;
}
free(temp); // 释放队头节点的内存空间
q->size--; // 队列长度减1
return data; // 返回取出的数据
}
//第几个月后
int k = 1;
//草地
char c[M][N]=
{{'.','.','.','.','.','.'},
{'.','.','.','.','g','.'},
{'.','g','.','.','.','.'},
{'.','.','.','.','.','.'},
{'.','.','g','.','.','.'},
{'.','.','.','.','.','.'}};
//bfs长草
void bfs(Queue *x,Queue *y){
//初始化:长草地址加入队列
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N ; ++j) {
if(c[i][j]=='g'){
enqueue(x,i);
enqueue(y,j);
}
}
}
//队列长度大于0
while(getLength(x)>0){
//出队
int qx = dequeue(x);
int qy = dequeue(y);
//循环拿到下一步
//移动方向
int mv[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
for(int i=0;i<4;i++){
int *temp = mv[i];
int tx = qx+temp[0];
int ty = qy+temp[1];
//如果下个方向可以长草
if(0<=tx&&tx<M && c[tx][ty]=='.'&&0<=ty&&ty<N){
//标记长草
c[tx][ty]='g';
//坐标加入队列
enqueue(x,tx);
enqueue(y,ty);
}
}
}
}
int main(){
printf("初始化草地:\n");
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N ; ++j) {
printf("%c ",c[i][j]);
}
printf("\n");
}
//创建队列
Queue x;
initQueue(&x); // 初始化队列
Queue y;
initQueue(&y); // 初始化队列
//长草
bfs(&x,&y);
printf("%d个月草地长草后:\n",k);
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M ; ++j) {
printf("%c ",c[i][j]);
}
printf("\n");
}
return 0;
}
![[蓝桥杯-610]分数](https://img-blog.csdnimg.cn/fdf263b57a4d43bc8c777c26b04cfc44.png)
