1 数据结构概述
（教材：严蔚敏、吴伟民，该书程序是伪算法具体的程序是高一凡）学完数据结构之后会对面向过程的函数有一个更深的了解。
1.1 定义
我们如何把现实中大量而复杂的问题以特定的数据类型（单个数据怎样存储？）和特定的存储结构（个体的关系）存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法。
（比如班里有15个人，其信息量也许一个数组就搞定了，但是假如10000个，怎么办？内存也许没有这么多连续的空间，所以我们改用链表， you see这就是与存储有关系。又比如，人事管理系统的信息存储，因为存在着上下级的关系，所以数组和链表就无能为力了，这时候我们用树，再比如我们做的是交通图，站和站之间肯定要连通，这时候以上的存储方式又无能为力了，所以我们又有了图。图就是每个结点都可以和其他结点产生联系。所以当我们要解决问题时，首先要解决的是如何把这些问题转换成数据，先保存到我们的主存中，）
数据结构
狭义：
数据结构是专门研究数据存储的问题
数据的存储包含两个方面：个体的存储 + 个体的关系的存储
广义：
数据结构既包含数据的存储也包含数据的操作
对存储数据的操作就是算法
算法
狭义：
算法是和数据的存储方式密切相关
广义：
算法和数据的存储方式无关
这就是泛型的思想
数据的存储结构有几种
线性
连续存储【数组】
优点：存取速度很快
缺点：插入删除元素很慢，空间通常是有限制的
离散存储【链表】
优点：空间没有限制，插入删除元素很快
缺点：存取速度慢
线性结构的应用
栈
队列
非线性
树
图
解题的方法和步骤
衡量算法的标准
1、时间复杂度
大概程序要执行的次数，而非执行的时间。
2、空间复杂度
算法执行过程中大概所占用的最大内存
3、难易程度（主要是应用方面看重）
4、健壮性（不能别人给一个非法的输入就挂掉）
数据结构的地位
数据结构是软件中最核心的课程
按数据结构的思路理解数据库：
字段（一个属性）
记录（一个事务）
表（一类事务的集合）
外键表示事务与事务之间的关系
程序 = 数据的存储＋数据的操作＋可以被计算机执行的语言（已经提供）
（学完数据结构，想用一种语言去实现它，必须有指针，数据结构java版，就胡扯，变味，因为我们要讲链表，就是通过指针链在一起的。比如在java中A aa = new A();本质上，aa是个地址）
2 预备知识
2.1 指针概述
指针的重要性：（内存是可以被CPU直接访问的，硬盘不行。主要靠地址总线，数据总线，控制总线访问内存。内存分为很多格子单元，格子编号范围是0-4G-1。地址总线确定对哪个单元进行操作，数据总线确定是读还是写。）
指针是C语言的灵魂
定义
地址
地址就是内存单元的编号
从0开始的非负整数
范围：0--FFFFFFFF[0-4G-1]（地址线是32位，刚好控制2的32次）
指针：
指针就是地址 地址就是指针
指针变量是存放内存单元地址的变量
指针的本质是一个操作受限的非负整数（不能加乘除，只能减）
分类：
2.2 基本类型的指针
# include <stdio.h>
int main(void)
{
int * p; //p是个变量名字, int * 表示该p变量只能存储int类型变量的地址
int i = 10;
int j;
p = &i;
*p = i; // 等价于 i = i;
// j = *p; // 等价于 j = i;
printf("i = %d, j = %d, *p = %d\n", i, j, *p);
return 0;
}
基本概念
int i=10;
int *p = &i; //等价于 int *p; p = &i;
详解这两部操作：
1. p存放了i的地址，所以我们说p指向了i
2. p和i是完全不同的两个变量，修改其中的任意一个变量的值，不会影响另一变量的值
3. p指向i，*p就是i变量本身。更形象的说所有出现*p的地方都可以换成i，所有出现i的地方都可以换成*p
总结：
1、 如何一个指针变量(假定为p)存放了某个普通变量(假定为i)的地址，那我们就可以说：“p指向了i”， 但p与i是两个不同的变量，修改p的值不影响i的值，修改i的值不影响p的值.
2、 *p等价于i 或者说*p可以与i在任何地方互换
3、 如果一个指针变量指向了某个普通变量，则
*指针变量 就完全等价于 该普通变量
注意：
指针变量也是变量，只不过它存放的不能是内存单元的内容，只能存放内存单元的地址
普通变量前不能加*
常量和表达式前不能加&
# include <stdio.h>
void f(int i)
{
*p = 100;
}
int main(void)
{
int i = 9;
f(i);
printf("i = %d\n", i);
return 0;
}
//最后输出结果为9，因为局部变量只能在本函数内部使用。
# include <stdio.h>
void f(int * p) //不是定义了一个名字叫做*p的形参, 而是定义了一个形参，该形参名字叫做p,它的类型是int *
{
*p = 100; //i的地址发送给p，*p就是i，即100赋给i，i变成了100
}
int main(void)
{
int i = 9;
f(&i);
printf("i = %d\n", i);
return 0;
}
最后输出结果为100
如何通过被调函数修改主调函数中普通变量的值
Ⅰ 实参为相关变量的地址 &i
Ⅱ 形参为以该变量的类型为类型的指针变量 int * p
Ⅲ 在被调函数中通过 *形参变量名 的方式就可以修改主函数相关变量的值 *p = 100
2.3 指针和数组的关系
指针 和 一维数组
数组名
一维数组名是个指针常量，
它存放的是一维数组第一个元素的地址，
它的值不能被改变
一维数组名指向的是数组的第一个元素，即a指向的是a[0]
下标和指针的关系
a[i] <<==>> *(a+i)
# include <stdio.h>
int main(void)
{
int a[5] = {
1,2,3,4,5};
//a[3] == *(3+a);
printf("%p\n", a+1);
printf("%p\n", a+2);
printf("%d\n", *a+3); //*a+3等价于 a[0]+3
return 0;
}
# include <stdio.h>
void Show_Array(int * p, int len)
{
int i = 0;
for (i=0; i<len; ++i)
printf("%d\n", p[i]);//输出1,2,3,4,5
//p[2] = -1; //若p[0] = -1，则主函数输出a[0]=-1，因为p[0] == *p就是p指向的元素a[0]，a[0]变化为-1；
//若p[2] = -1，则主函数输出a[2]=-1，因为p[2] == *(p+2) == *(a+2) == a[2]
//结论：p[i]就是主函数的a[i]
}
int main(void)
{
int a[5] = {
1,2,3,4,5};
Show_Array(a, 5); //a等价于&a[0], &a[0]本身就是int *类型，a发送给p
//printf("%d\n", a[2]);
return 0;
}
假设指针变量的名字为p
则p+i的值是p+i*(p所指向的变量所占的字节数)
指针变量的运算
指针变量不能相加，不能相乘，不能相除
如果两指针变量属于同一数组，则可以相减
指针变量可以加减一整数，前提是最终结果不能超过指针允许指向的范围
p+i的值是p+i*(p所指向的变量所占的字节数)
p-i的值是p-i*(p所指向的变量所占的字节数)
p++ <==> p+1
p-- <==> p-1
举例
如何通过被调函数修改主调函数中一维数组的内容【如何界定一维数组】
两个参数
存放数组首元素的指针变量
存放数组元素长度的整型变量
# include <stdio.h>
int main(void)
{
double * p;
double x = 66.6;
p = &x; //x占8个子节 1个字节是8位, 1个子节一个地址
double arr[3] = {
1.1, 2.2, 3.3};
double * q;
q = &arr[0];
printf("%p\n", q); //%p实际就是以十六进制输出
q = &arr[1];
printf("%p\n", q);
return 0;
}
//输出：0012FF5C 00122FF64 C=12 5C+8=64
指针在32位编译环境中只占4个字节，64位编译环境中占8个字节
通过函数修改实参的值
要想修改一个变量的值，如果函数没有返回值，只能在函数中放入地址用指针：
# include <stdio.h>
void f(int * p);//前置声明
int main(void)
{
int i = 10;
f(&i);
printf("i = %d\n", i);
return 0;
}
void f(int * p)
{
*p = 99;
}
更进一步的，无论p是什么类型的变量，要想改写它的值，只需要在函数中放它的地址。
# include <stdio.h>
void f(int ** q);
int main(void)
{
int i = 9;
int * p = &i;// int *p; p = &i;
printf("%p\n", p);
f(&p);
printf("%p\n", p);
return 0;
}
//p是int *类型，则&p是int **类型，指针的指针。把p的地址发送给q，*q=p
void f(int ** q)
{
*q = (int *)0xFFFFFFFF;
}
2.4 结构体（C++中用类也能实现）
为什么会出现结构体
为了表示一些复杂的数据，而普通的基本类型变量无法满足要求
什么叫结构体
结构体是用户根据实际需要自己定义的复合数据类型
结构体相当于java中的类，但是里面没有方法
如何使用结构体
两种方式：
struct Student st = {1000, "zhangsan", 20}
struct Student * pst = &st;
1.
st.sid
2.
pst->sid
表示pst所指向的结构体变量中的sid这个成员
使用结构体变量的第一种方式：
# include <stdio.h>
# include <string.h>
struct Student
{
int sid;
char name[200];
int age;
}; //分号不能省
//定义了一个新的数据类型，叫struct Student，里面有三个成员sid，name，age
int main(void)
{
struct Student st = {
1000, "zhangsan", 20};
//用struct Student数据类型定义了一个名为st的新变量。
printf("%d %s %d\n", st.sid, st.name, st.age);
st.sid = 99;
//st.name = "lisi"; //error，只有java能这样写
strcpy(st.name, "lisi");
st.age = 22;
printf("%d %s %d\n", st.sid, st.name, st.age);
//printf("%d %s %d\n", st); //error
return 0;
}
32位系统，内存中无论指针指向的变量类型是什么类型，指针变量都只占4个字节，比如int类型占4个字节，分4个格子，一个字节一个编号，那么就有4个编号，地址总线是32位，每个编号需要32根线，32根线能确定4G个不同状态，编号为0，线就是0，0，……0，编号为1，线就是0，0，……1，每个格子能存32位数据，也就是4个字节，指针变量指向的只是第一个编号的格子，
使用结构体变量的第二种方式：
# include <stdio.h>
# include <string.h>
struct Student
{
int sid;
char name[200];
int age;
}; //分号不能省
int main(void)
{
struct Student st = {
1000, "zhangsan", 20};
//st.sid = 99; //第一种方式
struct Student * pst;
pst = &st;
pst->sid = 99; //第二种方式 pst->sid 等价于 (*pst).sid 而(*pst).sid等价于 st.sid, 所以pst->sid 等价于 st.sid
return 0;
}
注意事项：
结构体变量不能加减乘除，但可以相互赋值
普通结构体变量和结构体指针变量作为函数参数的传递
（病毒就是靠访问正在运行的那些程序所占用的内存。Java中规定局部变量必须初始化，因为这些变量一开始都是垃圾值，但是属性不是必须初始化的，因为已经默认初始化为0）
# include <stdio.h>
# include <string.h>
struct Student
{
int sid;
char name[200];
int age;
}; //分号不能省
//前置声明不能漏，不然系统不知道f，g，g2是什么
void f(struct Student * pst);
void g(struct Student st);
void g2(struct Student *pst);
int main(void)
{
struct Student st; //已经为st分配好了内存，但是里面是垃圾数字，需要通过指针修改变量的值
f(&st);
g2(&st);
//printf("%d %s %d\n", st.sid, st.name, st.age);
return 0;
}
//这种方式耗内存 耗时间 不推荐，结构体变量直接赋值，相当于直接传了大约208个字节，而指针只占用4个字节。
void g(struct Student st)
{
printf("%d %s %d\n", st.sid, st.name, st.age);
}
void g2(struct Student *pst)
{
printf("%d %s %d\n", pst->sid, pst->name, pst->age);
}
void f(struct Student * pst)
{
(*pst).sid = 99;
strcpy(pst->name, "zhangsan");
pst->age = 22;
}
2.5 动态内存分配和释放
（使用malloc分配的就是动态内存，不使用的就是静态内存。动态分配的内存一定要手动释放，否则造成内存泄露。）
（java中A aa = new A();其实就是 A *p = (A *)malloc(sizeof(A))）
动态内存分配和释放：
动态构造一维数组
假设动态构造一个int型数组
int *p = (int *)malloc(int len);
1、 malloc只有一个int型的形参，表示要求系统分配的字节数
2、 malloc函数的功能是请求系统len个字节的内存空间，如果请求分配成功，则返回第一个字节的地址，如果分配不成功，则返回NULL
3、 malloc函数能且只能返回第一个字节的地址，所以我们需要把这个无任何实际意义的第一个字节的地址（俗称干地址）转化为一个有实际意义的地址，因此malloc前面必须加（数据类型 *）,表示把这个无实际意义的第一个字节的地址转化为相应类型的地址。如：
int *p = (int *)malloc(50);
表示将系统分配好的50个字节的第一个字节的地址转化为int *型的地址，更准确的说是把第一个字节的地址转化为四个字节的地址，这样p就指向了第一个的四个字节，p+1就指向了第2个的四个字节，p+i就指向了第i+1个的4个字节。p[0]就是第一个元素， p[i]就是第i+1个元素
double *p = (double *)malloc(80);
表示将系统分配好的80个字节的第一个字节的地址转化为double *型的地址，更准确的说是把第一个字节的地址转化为8个字节的地址，这样p就指向了第一个的8个字节，p+1就指向了第2个的8个字节，p+i就指向了第i+1个的8个字节。p[0]就是第一个元素， p[i]就是第i+1个元素
free（p）
释放p所指向的内存，而不是释放p本身所占用的内存
# include <stdio.h>
# include <malloc.h>
int main(void)
{
int a[5] = {
4, 10, 2, 8, 6};//静态分配内存
//用指针动态分配内存，模拟数组
int len;
printf("请输入你需要分配的数组的长度: len = ");
scanf("%d", &len);
int * pArr = (int *)malloc(sizeof(int) * len);
//sizeof(int)是整型的字节数，若len=5，则(sizeof(int) * len)=20，20表示malloc函数请求操作系统为程序分配20字节的空间。(int *)是强制转换，无论一个变量占几个字节，malloc函数只能返回第一个字节地址，这个地址是无意义地址（干地址），所以前面需要强制转换，告诉编译器第一个地址是什么类型（int or double……）的地址
// *pArr = 4; //类似于 a[0] = 4;
// pArr[1] = 10; //类似于a[1] = 10;
// printf("%d %d\n", *pArr, pArr[1]);
//我们可以把pArr当做一个普通数组来使用
for (int i=0; i<len; ++i)
scanf("%d", &pArr[i]);
for (i=0; i<len; ++i)
printf("%d\n", *(pArr+i));
free(pArr); //把pArr所代表的动态分配的20个字节的内存释放
return 0;
}
跨函数使用内存:
8、下列程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是
A) main()
{
int *p;
fun(p);
…
}
int fun(int *p)
{
int s;
p=&s;
}
B) main()
{
int *p;
fun(&p);
…
}
int fun(int **q)
{
int s;
*q=&s;
}
C) #include <stdlib.h>
main()
{
int *p; //p变量地址发送给q，则*q=q
fun(&p);
…
}
int fun(int **q)
{
*q=(int *)malloc(4); //p指向4个字节，函数执行完后，这4个字节没有消失，因为内存没释放
}
D)
#include <stdlib.h>
main()
{
int *p;
fun(p);
…
}
int fun(int *p)
{
p=(int *)malloc(sizeof(int));
}
注释： 这个题很有意思。考查了：
- 指针的指针的使用 2) 动态内存分配与自动变量的内存分配。
动态分配的内存必须调用free()函数才能释放，而自动变量一旦跳出它的代码作用范围，就会由编译器自动释放掉。
让我们先看：
A) 选项无论fun()中p的值如何变化，都不会影响到主函数中p的值，因为它是值传递
B) 选项倒是把p的地址&p传递给了fun()函数，但遗憾的是，由于s是个自动变量，当推出fun()函数后，s变量所占内存单元会被会被释放掉，此时主函数中的p还是没法指向一个合法的int型单元
C) 选项fun()的形参 int **p;表明p是个指向指针变量的指针变量，即是个指针的指针。 而主函数中的 int *p; 表明p只是个指针变量，但&p则指向了p，&p也是个指向指针变量p的指针变量，实参和形参类型一致。 fun()的功能是使实参p指向了一个int型变量， 又由于该int型变量是由malloc()动态分配的，所以推出fun()函数并不会影响实参p的指向， 故C是对
D) 选项犯了和A同样的错误。 真想不到二C还会考到这个知识，哈哈!
# include <stdio.h>
# include <malloc.h>
struct Student
{
int sid;
int age;
};
struct Student * CreateStudent(void);
void ShowStudent(struct Student *);
int main(void)
{
struct Student * ps;
ps = CreateStudent();
ShowStudent(ps);
return 0;
}
void ShowStudent(struct Student * pst)
{
printf("%d %d\n", pst->sid, pst->age);
}
struct Student * CreateStudent(void)
{
struct Student * p = (struct Student *)malloc(sizeof(struct Student));
p->sid = 99;
p->age = 88;
return p;
}
//输出99 88