一.结构体
0.前言
我们所学过的类型如：char,int,float,double等，都只能描述单一变量。但是结构体，顾名思义，是多个变量的集合，其中包含多个单一变量。所以C语言就发明了结构体用于用来描述复杂对象，如：书，人等具有多个特征的变量。
1.定义
结构（体）是一些值的集合，这些值被称为成员变量。结构的每个成员变量可以具有不同类型。
1.1 语法结构
struct node//结构体类型名，你不止可以有node，还可以有tree等等不同的结构体
{
int a;
char b=1; //成员列表,可以直接初始化
double c;
}a;//变量列表(全局变量)
注：1.因为结构体的声明是在主函数外，所以直接在结构体后面定义的变量是一个全局变量，想要局部变量就要在主函数里再创建2.不要把定义变量和声明结构体搞混了，上面a是变量，node是结构体名字
1.2 结构体的创建
结构体用于描述复杂对象的多个属性，必然具有多个成员变量。结构体成员的类型可以是常量，数组，指针，也可以是其他结构体。
struct book//书
{
char name[20];//书名
char author[15];//作者
float price;//价格
}b1,b2;//全局变量
struct point//坐标
{
int x;
int y;
};
int main()
{
struct book b;//局部变量
return 0;
}
其实在主函数内部声明也可以，但是习惯上来讲在全局声明结构体比较多，而且一些函数也可能用到结构体。
int main() {
struct book {
char name[20];
char author[15];
float price;
}b1, b2;
struct book b;
return 0;
}
其实还有一种方法是对typedef对类型重定义，如：
typedef struct human
{
char name[20];
int age;
char id[20];
}hu;//这里的hu就不再是定义变量
//因为typedef就是=的意思，所以hu=struct human
struct human
{
char name[20];
int age;
char id[20];
};
typedef struct human hu;
int main() {
//1.
struct human man;
//2.
hu man;//这两种等价
return 0;
}
2.结构体变量的定义和初始化
可以直接在结构体声明后面定义和初始化。
struct book
{
char name[20];
char author[15];
float price;
}b1, b2;
struct book b3 = { 0 };
struct point {
int x;
int y;
};
struct point p1 = { x, y };
也可以在main函数中定义和初始化。
typedef struct human{
char name[20];
int age;
char id[20];
}hu;
int main() {
struct human man1 = { "sam",18,"8208220628" };
point p1 = { 1,2 };
return 0;
}
如果有需要，甚至可以嵌套定义和初始化。
struct S {
int a;
char c;
double d;
};
struct T {
struct S s;//定义一个S的s套进了T
char name[20];
int num;
};
int main() {
struct T t = { {10, 'x', 1.00}, "yourfriendyo", 21 };//结构体里的结构体初始化也要加{}
return 0;
}
3.结构体成员的访问
3.1 .操作符
结构体成员是通过操作符.进行访问的，.操作符具有两个操作数。左边是结构体变量名，右边是结构体成员名。
//直接用上面的结构体
printf("%d\n",t.num);
printf("%d\n",t.s.a);//嵌套的访问也是一样的，s是t的成员变量,a是s的成员变量
3.2 ->&*操作符
当然有的时候有可能我们需要的是一个指向该结构体的指针。这时候我们就需要操作符->，同样也是两个操作数，如：
//1.
struct T *pt=&t;
printf("%d %c %lf %s %d\n", (*pt).s.a, (*pt).s.c, (*pt).s.d, (*pt).name, (*pt).num);
//2.通常采用这个写法，这样更加直观
printf("%d %c %lf %s %d\n", pt->s.a, pt->s.c, pt->s.d, pt->name, pt->num);
//3.
struct S* ps = &(t.s);
printf("%d %c %lf %s %d\n", ps->a, ps->c, ps->d, pt->name, pt->num);c
1.第一种方法是我们不知道->，直接引用。
2.第二种方法->是专门在访问结构体时使用指针的方法。
3.第三种方法更加简单粗暴，我们越过了结构体变量t，直接创建指针指向(t.s).
二.指针
0.为什么要用指针
可能很多人觉得“啊，这东西长得又丑又难用，我为什么要学它” 确实 不，我们应该知道指针的好处：
1.C语言中有一些复杂的数据结构往往需要用指针来构建，如链表和二叉树
2.C语言是传值调用，而有些操作传值调用是无法完成的，如通过被调函数修改调用函数的对象，但是这种操作可以由指针来完成，而且并不违背传值调用。（人话就是函数里的改变是函数里的变量，对主函数不起作用，用指针就会对主函数起作用）
3.指针的使用使得不同区域的代码可以轻易的共享内存数据，这样可以使程序更为快速高效
1.什么是指针
1.1 概念
简单的来说，指针就是地址。我们口头上说的指针其实指的是指针变量。指针变量就是一个存放地址的变量。
1.2 指针的大小
指针在32位机器下是4个字节，在64位机器下是8个字节。（有兴趣可以自己拿sizeof函数测一下）
注：（指针的大小与类型无关）
2.如何声明一个指针
2.1 声明并初始化一个指针
声明
int *p; // 声明一个 int 类型的指针 p
char *p // 声明一个 char 类型的指针 p
int *arr[10] // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向 int 类型对象的指针
int (*arr)[10] // 声明一个数组指针，该指针指向一个 int 类型的一维数组
指针的声明比普通变量的声明多了一个一元运算符 *。运算符 * 是间接寻址或者间接引用运算符。当它作用于指针时，将访问指针所指向的对象。在上述的声明中： p 是一个指针，保存着一个地址，该地址指向内存中的一个变量； *p 则会访问这个地址所指向的变量。
int *p,a;
i=3;//直接访问：按变量地址存取变量值
*p=20;//间接访问：通过存放变量地址的变量去访问变量
//效果一样
初始化
声明一个指针变量并不会自动分配任何内存。在对指针进行间接访问之前，指针必须进行初始化：或是使他指向现有的内存，或者给他动态分配内存，否则我们并不知道指针指向哪儿，这将是一个很严重的问题，稍后会讨论这个问题。初始化操作如下：
//1：使指针指向现有的内存
int x=1;
int* p=&x;// 指针p被初始化，指向变量x，其中取地址符&用于产生操作数内存地址
//&x的运算结果是一个指针，p的类型是x的类型加个*，p所指向的类型是a的类型，p所指向的地址嘛，那就是x的地址
//2：动态分配内存给指针
int *p;
p = (int *)malloc(sizeof(int)*10);// malloc 函数用于动态分配内存
free(p);
// free 函数用于释放一块已经分配的内存，常与 malloc 函数一起使用，要使用这两个函数需要头文件 stdlib.h
指针的初始化实际上就是给指针一个合法的地址，让程序能够清楚地知道指针指向哪儿。
注:1.指针变量数据类型必须与所赋值的变量类型一致 float y; int *p; p=&y;
2.不允许把一个数（常量）赋予指针变量 int *p; p=1000;
3.被赋值的指针变量前不能再加*说明符，如写为*p=&a 也是错误的。但对于在定义指针的同时赋值是允许的，如：int *p=&a;其实质可分解为两句，即：int *p;p=&a;
2.2 非法情况
1.指针未被初始化
如果一个指针没有被初始化，那么程序就不知道它指向哪里。它可能指向一个非法地址，也可能指向一个合法地址，实际上，这种情况更严重，你的程序或许能正常运行，但是这个没有被初始化的指针所指向的那个位置的值将会被修改，而你并无意去修改它。
2.指针越界访问
int a[5];
int *p=a[0];
p+=5;//此时p就越界了
3.指针指向的空间释放
int* test( )
{
int a=5;
return &a;
}
int main()
{
int* p=test();
*p=10;
return 0;
}//变量a的地址只在test()函数内有效，当把a的地址传给指针p时，因为出了test函数，变量a的空间地址释放，导致p非法
2.3 如何规避非法
对于初学者，和学有所成者，非法情况都是必不可少的。解决方法如下：
1.小心越界 2.避免返回局部变量的地址 3.及时把指针赋成空指针（NULL 指针）
注：NULL 指针是一个特殊的指针变量，表示不指向任何东西。
int *p = NULL;
指针的地址为空值，也可以理解为0。内存地址 0 有一个特别重要的意义，它表明该指针不指向一个可访问的内存位置。
3.指针的运算
C指针的算术运算只限于两种形式：
3.1 指针 +/- 整数
可以对指针变量 p 进行 p++、p--、p + i 等操作，所得结果也是一个指针，只是指针所指向的内存地址相比于 p 所指的内存地址前进或者后退了 i 个操作数。这为我们提供了另外一种可以取代下标法的方法来处理数组。
如果指针p指向元素a[i],那么p+j指向a[i+j]
在计算机内部：
p 是一个 int 类型的指针，指向内存地址 0x10000008 处。则 p-- 将指向与 p 相邻的下一个内存地址，由于 int 型数据占 4 个字节，因此 p-- 所指的内存地址为 10000004。其余类推。
不过要注意的是，这种运算并不会改变指针变量 p 自身的地址，只是改变了它所指向的地址。
3.2 指针-指针
一个指针减去另外一个指针，其结果是两个指针所指元素之间的距离，如果p 指向a[i]且q指向a[j],那么 p - q等于 i - j。
注意：只有当两个指针都指向相同数组时，指针相减才有意义。
3.3 指针的比较（实际为3.2的推广）
指针可以用关系运算符 \((<, <= , >, >=)\) 和 等号运算符 (== and !=)进行比较.并且仅当两个相互比较的指针指向同一数组元素，比较才有意义。
3.4 *运算符和 ++ 的组合
p=&a[0];
a[i++]=j;
*p++=j;//两个等价，有时能节省时间
--同理
指针运算是数组与指针关联的一种方式，其余方式将在4.2中讲述。
4.其他指针
4.1 二维指针及多维指针
略，作者偷懒中
4.2 指针与数组
4.3 指针与函数
4.4 结构体指针
赋值就是把结构变量首地址赋予该指针变量，不能把结构名赋予该指针变量。
pt=&t;//是正确的
pt=&T;//是错误的
结构名只能表示一个结构形式，编译系统并不对他们分配内存空间，没有地址。只有定义了这种类型的结构的变量时，才对该变量存储内存空间。
4.5 字符指针
5.例题
例一：找出数组中的最大元素和最小元素
Enter 10 numbers: 34 82 49 102 7 94 23 11 50 31
Largest: 102 Smallest: 7
void max_min(int a[], int n, int *max, int *min)
{
int i;
*max = *min = a[0];
for (i = 1; i < n; i++)
{
if (a[i] > *max)
*max = a[i];
else if (a[i] < *min)
*min = a[i];
}
}
例二：swap函数
void swap(int *a,int *b){
int tmp=*a;
*a=*b;
*b=*a;
}
三.链表
1.链表是什么
1.1 定义
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
在c语言中，链表是一种常见的基础数据结构，可以细分为一小块一小块的结构体变量（节点），这一小块一小块的结构体变量在链表中是首尾相连的。而这每一个节点又可以分成两个部分， 其中一个部分就是涵盖着该结构体变量里的所有信息，另一个部分就是链接每块结构体变量的部分——指针。
1.2 链表的特点
用时申请，不用时释放，插入和删除只需少量操作，能大大提高空间利用率和时间效率。
在链表中，有一个头指针变量，只保存一个地址，头指针指向一个变量，称为节点。在链表中，每一个节点包含两部分：数据部分和指针部分。数据部分用来存放元素所包含的数据，指针部分用来指向下一个节点。最后一个节点的指针指向NULL，表示指向的地址为空（链尾）。
2.链表的相关操作
作为有强大功能的链表，对他的操作当然有许多，比如：链表的创建，修改，删除，插入，输出，排序，反序，清空链表的元素，求链表的长度等等。
因为咱们初讲链表，就以最基本的单链表为例。（接下来的链表均指单链表）
创建链表节点结构体
typedef struct Node
{
int data;
struct Node *next;
}Link;//Link就代指这是链表的结构体
一般创建链表我们都用 typedef struct，因为这样定义结构体变量时，我们就可以直接可以用 Link;
初始化链表
//尾插法
Link *creatlist(int n)//n为节点个数
{
Link *head,*node,*tail;//定义头节点，普通节点，尾部节点
head=NULL;
for(int i=1;i<=n;i++)
{
node=(Link *)malloc(sizeof(Link));//动态分配内存
scanf("%d",&node->data);
if(head==NULL) head=node;
else tail->next=node;
tail=node;
}
tail->next=NULL;
return head;
}
//头插法
Link *creatlist(int n)
{
Link *head,*node,*tail;//一样定义头节点，普通节点，尾部节点
tail=NULL;
for(int i=1;i<=n;i++)
{
node=(Link *)malloc(sizeof(Link));
scanf("%d",&node->data);
if(tail==NULL) tail=node;
else node->next=head;
head=node;
}
tail->next=NULL;
return head;
}
按值查找
Link *search_data(Link *head,int point)
{
Link *node=head->next;
while(node!=NULL&&node->data!=point)
{
node=node->next;
}
return node;
}
按位置查找
LNode *search_pos(Link *head,int pos)
{
if(pos==0)
return head;
Link *node=head;
int j=0;
while(node!=NULL&&j<pos)
{
node=node->next;
j++;
}
return node;
}
修改链表节点值
就是按位置查找后修改即可，不再展示代码
删除链表节点
void delete(Link *head,int pos)
{
Link *node,*del_node;//del_node即为我们要删除的节点
node=search_pos(head,pos-1);//找到待删除结点的前驱结点
del_node=node->next;
node->next=del_node->next;//前驱结点指向待删除结点的后继结点
free(del_node);//释放待删除结点所占的内存空间（至此，在逻辑与物理上都删除了该节点）
}
//一定要记得free掉待删除结点，不free的话，好的情况只是占用了内存，坏情况成为非法指针造成内存泄漏
插入链表节点
void insert(Link *head,int pos,int point){
Link *node;
Link *new_node=(Link *)malloc(sizeof(Link));
new_node->data=point;
node=search_pos(head,pos-1);
new_node->next=node->next;
node->next=new->node;//不能写反，不然逻辑混乱，导致new_node自己指向自己
}
输出链表
void printlist(Link *head){
Link *node=head->next;
while(node!=NULL)
{
printf("%d ",node->data);
node=node->next;
}
printf("\n");
}
3.进阶链表
3.1 循环链表
3.2 双向链表
4.进阶链表操作及问题
暂略，太难了——大厂面试考题(●'◡'●)
标签：node,变量,int,struct,链表,指针,结构 From： https://www.cnblogs.com/jasony/p/16989239.html