C语言学习笔记总结（一）

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库，这个库中包含了用于文件操作的函数，例如：

1. fopen()：打开文件；
2. fclose()：关闭文件；
3. fgetc()：从文件中读取一个字符；
4. fgets()：从文件中读取一行；
5. fprintf()：将格式化的数据写入文件；
6. 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；其最大价值为0for (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)) { // 如果队列为空，返回错误码-1return -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--; // 队列长度减1return 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);}}}//队列长度大于0while(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;
}