C语言知识点思维导图

整型

实型

字符型

数组

结构体

共用体

枚举

如：int a = 10; short s = 20; unsigned long = 65535;等

如：float f = 3.1415f;

只能使用单引号将单个字符包括进来

由0-多个字符组成

用标识符表示的常量，例如：define PI 3.1415926

&

|

~

^

<<

>>

https://blog.csdn.net/weixin_45743799/article/details/104531619

思想：将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。） #include <stdio.h> #define LEN 5 int a[LEN] = {10, 5, 2, 4, 7}; void insertion_sort(void) { int i, j, key; for (j = 1; j < LEN; j++) { printf("%d, %d, %d, %d, %d\n", a[0], a[1], a[2], a[3], a[4]); key = a[j]; i = j - 1; while (i >= 0 && a[i] > key) { a[i + 1] = a[i]; i--; } a[i + 1] = key; } printf("%d, %d, %d, %d, %d\n", a[0], a[1], a[2], a[3], a[4]); } int main(void) { insertion_sort(); return 0; }

思想：升序时，第一次：将最大的值放到数组的最后一个；第二次：将次大值放到数组的倒数第一个位置 void bubble(int arr[],int n) { int i ,j ,tmp; for(i =0;i < n-1;++i) { for(j =0; j < n-i-1;++j) { if(arr[j]>arr[j+1]) { tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } } }

思路：选一个数字和后边的数字进行依次比较，记录本次最小下标后，内层循环完成后再进行交换： void select (int arr[],int n) { int i ,j,min,tmp; for(i = 0 ;i < n-1;++i) { min = i; for(j = i+1;j < n;++j) { if(arr[min]>arr[j]) { min = j; } } if(i!=min) { tmp = arr[i]; arr[i] = arr[min]; arr[min] = tmp; } } }

1、选定一个数字，作为中心点

2、将小于中心点的数字放在左边

3、将大于中心点数字的放在右边

4、对左右子序列重复1-3步

核心思想： 1、选择中心点（一般情况下选择第一个点） 2、将大于中心点值的元素放在中心点的右侧，右侧的点称为右子序列 3、将小于中心点值的元素放在中心点的左侧，左侧的点称为左子序列 4、分别对左右子序列进行上述1-3步的排序 void quick_sort(int arr[], int left, int right) { if (left >= right) return; int l = left; int r = right; int key = arr[l]; while (l < r) { while (l < r && arr[r] >= key) { r--; } if (l < r) { arr[l] = arr[r]; l++; } while (l < r && arr[l] <= key) { l++; } if (l < r) { arr[r] = arr[l]; r--; } } arr[l] = key; quick_sort(arr, left, l - 1); quick_sort(arr, r + 1, right); } int main() { int nums[] = {8, 4, 3, 2, 10, 2}; int len = sizeof(nums) / sizeof(int); quick_sort(nums, 0, len-1); for (int i = 0; i < len; ++i) { printf("%d ", nums[i]); } }

归并操作的工作原理如下： 第一步：申请空间，使其大小为待排序数列排序，该空间用来存放合并后的序列 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 重复步骤3直到某一指针超出序列尾 将另一序列剩下的所有元素直接复制到合并序列尾 稳定性 : 稳定 时间复杂度 : O(N*logN) 空间复杂度 : O(N)

#include<stdio.h> #include<stdlib.h> #include<time.h> #define N 100 void dealMergeSort(int* src, int* tmp, int start, int end) { if (start >= end) {//前后指针交替, 已经二分完毕 return; } int mid = (start + end) / 2; dealMergeSort(src, tmp, start, mid); dealMergeSort(src, tmp, mid + 1, end); int a = start;//分后前一部分数组的起始坐标 int b = mid + 1;//分后后一部分数组的起始坐标 int c = start;//临时数组起始坐标, 将存储前后两个有序数组归并后的有序数组 while (a <= mid && b <= end) { if(src[a]<src[b]){ tmp[c] = src[a]; ++a; } else { tmp[c] = src[b]; ++b; } ++c; } //循环跳出时不一定左右两个有序数组同时遍历结束 , 但未遍历完的一个数组盛夏的肯定是比另一个遍历完的数组最大值还大的有序数列 //直接给临时数组tmp //以下两个for循环只进一个 for (; a <= mid; ++a,++c) { tmp[c] = src[a]; } for (; b <= end; ++b, ++c) { tmp[c] = src[b]; } //将存在临时数组中的合并的有序数列再给待排序数组src for (int i = start; i <= end; ++i) { src[i] = tmp[i]; } } void MergeSort(int* src, int size) { int* tmp = (int*)malloc(size * sizeof(src[0])); dealMergeSort(src, tmp, 0, size - 1); free(tmp); } void PrintArray(int* src, int size) { for (int i = 0; i < size; ++i) { printf("%d ", src[i]); } putchar('\n'); } int main() { srand((unsigned int)time(0)); int src[N]; int src1[10] = { 8,7,10,2,3,5,6,1,4,9 }; for (int i = 0; i < N; ++i) { src[i] = rand() % N + 1; } //printf("排序前:\n"); //PrintArray(src, N); MergeSort(src, N); MergeSort(src1, 10); PrintArray(src1, 10); //printf("排序后:\n"); PrintArray(src, N); system("pause"); return 0; }

前提是数组必须是有序的，使用二分查找速度会快很多 int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int sz = (sizeof(arr) / sizeof(arr[0])); int left = 0; int right = sz - 1; int num = 7; while (left <= right) { int mid = (left + right) / 2; if (arr[mid] < num) { left = mid + 1; } else if (arr[mid] > num) { right = mid - 1; } else { printf("找到了，下标是:%d", mid); break; } } if (left > right) { printf("没有找到"); } return 0; }

存放代码，不允许修改，但可以执行（类似于常量存储区，不可修改但可以执行）

全局和静态变量被分配到同一个内存中

动态申请的内存，由程序员申请并释放，如果不及时释放会造成内存泄漏

由编译器自动维护，在不需要时自动清除，存放局部变量，函数参数及方法地址等。

存放常量，不允许修改

在堆中开辟一块size大小的内存空间

在堆中开辟一块n个长度为size的练习内存空间数组

改变ptr指针指向空间大小

使用由指针ptr指向的内存区，释放内存

头文件在stdlib.h中

函数原型：void *memset(void *s, int ch, size_t n);

作用：将malloc动态申请的内存的随机数初始化为指定的值

头文件：string.h

1: int *pOld = (int*)malloc(sizeof(int)); int *pNew = (int*)malloc(sizeof(int)); pOld = pNew; free(pOld) //free(pOld)释放的是pOld所指向的内存空间即原来pNew,但pOld原来指向的内存空间还没有被释放。

2: int main() { char *p; p = (char *)malloc(100); p = "hello world"; // p指向其他地方，把字符串的首地址赋给p；这样子导致原本堆区的空间找不到了 //从此刻起，再也找不到申请的100个字节的空间，动态申请的100个字节被泄漏了 return 0; }

3: void test1() { char *p; p =(char *)malloc(100); //接下来，可以用p指向内存了 ， //... //没有释放，没有返回，这样导致这个函数执行完后不知道这个申请的内存空间在哪了 } void main() { //每次用一次fun泄露100个字节 test1(); test1(); }

auto

register

static

extern

即使用static修饰的函数，只能在所定义的.c中函数调用

使用extern修饰的函数，默认不加extern的函数都是外部的， 在所有地方都可以调用

1、以下两种方式是一样的： const int num=10; int const num=10; 2、char *p = "china"; p[2] = 'a';//编译错误

常量指针，不能改变指向存储单元的值，但可以修改指针的指向

指针常量，不能改变指针的地址，指向的存储单元值可以修改

既不能修改值也不能修改地址的写法： int b = 1; const int *const a = &b;

指的是一个函数的返回值为指针类型

指的是函数的入口地址（存储在代码区中的代码）

calc.c

把函数指针作为函数参数传递给另外一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数

回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外一方调用，用于对该事件或者条件进行响应

1、定义一个回调函数

2、提供函数调用的另一方在初始化时，将回调函数的函数指针传递给调用者

3、当特定的事件或条件发生的时候，调用者使用函数指针调用所指向的回调函数对事件进行处理。

leader.c

teacher.c

teacher.h

维护性好

例如： int a = 10; void *p = &a;

指针数组

数组指针

指向数组和指向数组首元素区别

行地址： a：表示第1行的行地址 &a[0]:表示第1行的行地址 &*(a+0) &a[1]:表示第2行的行地址 &*(a+1) 列地址： a[0]：表示第1行第1列的列地址 *(a+0) a[1]：表示第2行第1列的列地址 *(a+1) *a：拿到的是第1行第1列的列地址 *(a）+1：拿到的是第1行第2列的列地址 *(a+1)+1:拿到的是第2行第2列的列地址

1、每行的行地址与每行第1列地址是相同的，虽然值相同，但是两者是不一样的含义。行地址代表的是行的地址用来确定第几行，而列地址用来表示某行某列的地址。

二维数组遍历方式

计算出现次数，如最长/最短子串、子数组、子序列等问题，例如：长度最小的子数组

dynimac programming 简称DP，一般情况下动态规划需要使用数组，所以也叫DP数组。 简单来说，动态规划其实就是，给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后把子问题答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法

动态规划最核心的思想，就在于拆分子问题，记住过往，减少重复计算。

clion中文乱码修改.png