郝斌数据结构自学笔记--知识点+程序源代码(共62页)

《郝斌数据结构自学笔记--知识点+程序源代码(共62页)》由会员分享，可在线阅读，更多相关《郝斌数据结构自学笔记--知识点+程序源代码(共62页)（62页珍藏版）》请在装配图网上搜索。

1、精选优质文档-倾情为你奉上郝斌数据结构自学笔记-知识点+程序源代码2015.12 By-HZM1_什么叫做数据结构数据结构概述定义我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法。数据结构=个体的存储+个体的关系存储算法=对存储数据的操作2_衡量算法的标准算法解题的方法和步骤衡量算法的标准1）时间复杂度：大概程序执行的次数，而非执行的时间2）空间复杂度：算法执行过程中大概所占用的最大内存3）难易程度4）健壮性3_数据结构的特点数据结

2、构的地位数据结构是软件中最核心的课程程序=数据的存储+数据的操作+可以被计算机执行的语言4_预备知识_指针_15_预备知识_指针_2指针的重要性：指针是C语言的灵魂定义：地址：地址是内存单元的编号,从0开始的非负整数，范围：0-FFFFFFFF【0-4G-1】CPU=地址线，控制线，数据线=内存指针：指针就是地址，地址就是指针。指针变量是存放内存单元地址的变量。指针的本质是一个操作受限的非负整数。分类：1.基本类型的指针2.指针和数组的关系变量并不一定连续分配，随机分配内存。内存：内存是多字节组成的线性一维存储空间。内存的基本划分单位是字节。每个字节含有8位，每一位存放1个0或1个1.内存和编

3、号是一一对应的。软件在运行前需要向操作系统申请存储空间。在软件运行期间，该软件所占空间不再分配给其他软件。当软件运行完毕后，操作系统将回收该内存空间（操作系统并不清空该内存空间中遗留下来的数据）。NOTE：1）指针变量也是变量，普通变量前不能加*，常亮和表达式前不能加&。2）局部变量只在本函数内部使用。如何通过被调函数修改主调函数中普通变量的值。1）实参为相关变量的地址；2）形参为以该变量的类型为类型的指针变量；3）在被调函数中通过 *形参变量名的形式 的形式就可以修改主函数。CASE 1#includeint main(void)int *p;/p是个变量名字，int*表示该p变量只能存储i

4、nt类型变量的地址int i=10;int j;/j=*p;/printf(%dn,j);/error,p未指定/char ch=A;/p=&ch;/error，类型不一致p=&i; /p保存i的地址，p指向i；修改p的值不影响i的值，修改i的值不影响p的值；任何场合下，*p和i可以互换。*p等价于i。/p=10;/errorj=*p;/等价于j=i;printf(i=%d,j=%d,*p=%dn,i,j,*p); return 0;CASE 2#includevoid f(int * i)/不是定义了一个名字叫做*i的形参，而是定义了一个形参，该形参名字叫做i，它的类型是int*i=100;

5、int main(void)int i=9;f(&i);/局部变量只在本函数内部使用。printf(i=%dn,i);指针和数字数组名：一维数组名是个指针变量，它存放的是一维数组第一个元素的地址，它的值不能被改变，一维数组名指向的是数组的第一个元素。CASE 1a3=*(3+a); 3a =*(a+3)=*(3+a);int a5=1,2,3,4,5;Show_Aarry(a,5);/a等价于&a0,&a0本身就是int*类型void Show_Array(int * p,int len)Int I;/P2=-1;/ p0=*p ; p2=*(p+2)=*(a+2)=a2 ; pi就是主函数的

6、aifor (i=0;ilem;i+)printf(“%dn”,pi);指针变量的运算指针变量不能相加，不能相乘，不能相除。如果两指针变量属于同一数组，则可以相减。指针变量可以加减一整数，前提是最终结果不能超过指针变量p+i的值是p+i*(p所指向的变量所占的字节数)p-i的值是p-i*(p所指向的变量所占的字节数)p+p+1 p-P-16_所有的指针变量只占4个子节 用第一个字节的地址表示整个变量的地址CASE 1double *p;double x=66.6;/一个double占8个字节p=&x;/x占8个字节，1个字节是8位，1个字节一个地址，p内只存放了一个地址，通常是字节的首地址do

7、uble arr3=1.1,2.2,3.3;double *q;q=&arr0;printf(“%pn”,q); /%p实际就是以十六进制输出q=&arr1;q=printf(“%pn”,q);/p,q相差8无论指针指向的变量占多少个字节，指针变量统一都只占4个字节7_如何通过函数修改实参的值发送地址CASE 1 修改指针变量的值，只能修改地址void f(int *);int main(void)int i=9;int *p=&i;/*p;p=&i;printf(“%pn”,p);f(&p); printf(“%pn”,p);return 0;/void f(int *q)/q=(int *

8、)0xffffffff; /错误，不会改变p的值/void f(int * q)*q=(int *)0xffffffff; 8_结构体的使用概述结构体为什么会出现结构体：为了表示一些复杂的数据，而普通的基本类型变量无法满足要求什么叫做结构体：结构体是用户根据实际需要自己定义的复合数据类型如何使用结构体：两种方式struct Student st=1000,”zhagnsan”,20;struct Student*pst=&st;1)通过结构体变量名来实现st.sid2)通过指向结构体变量的指针来实现【重点】pst-sidpst所指向的结构体变量中的sid这个成员CASE 1#include#i

9、nclude struct Studentint sid；char name200;int age;/分号不能省Int main(void)struct Student st=1000,”zhagnsan”,20;printf(“%d,%s%dn,”,st.sid,st.name,st.age);printf(“%d,%s%dn,”,st);/errorst.sid=99;/第一种/st.name=”lisi”;/error strcpy(st.name,”lisi”);st.age=22;struct Student*pst;pst=&st;/第二种pst-sid=99;/pst-等价于(*

10、pst).sid，而(*pst).sid等价于st.sid，所以pst-sid等价于st.sidReturn 0;注意事项：结构体变量不能加减乘除，但可以相互赋值普通结构体变量和结构体指针变量作为函数传参的问题CASE 2#includestruct Studentint sid；char name200;int age;void f(struct Student *pst);void g(struct Student st);void g2(struct Student *pst);int main (void)struct Student st;/已经为st分配好了内存f(&st);/g(

11、st);g2(&st);/ printf(“%d %s %dn”,st.sid,st.name,st.age);/输出方法一return 0;void g(struct Student st)/整体变量赋值/输出方法二，速度慢，耗空间，耗内存，不推荐printf(“%d %s %dn”,st.sid,st.name,st.age);void g2(struct Student *pst)printf(“%d %s %dn”,pst-sid,pst-name,pst-age);void f(struct Student *pst)(*pst).sid=99;strcpy(pst-name,”zh

12、agnsan”);pst-age=22;9_malloc()动态分配内存概述动态内存的分配和释放CASE 1#icclude#includeint main(void)int a5=1,2,3,4,5;/静态数组int len;printf(“请输入你需要分配的数组长度：len=”);scanf(“%d”,&len);int *pArr=(int *)malloc(sizeof(int)*len);/(int *)为强制转换，强制使pArr指向前四个字节。可以将pArr当做数组名来操作/*pArr=4;/类似于a0=4;/pArr1=10;/类似于a1=10;/printf(“%d %dn”,

13、*pArr,pArr1);/我们可以把pArr当做一个普通数组来使用for (int i=0;ilen;+i)scanf(“%d”,&pArr);for (i=0;ilen;+i)printf(“%dn”,*(pArr+i);free(pArr);/把pArr所代表的的动态分配的20个字节的内存释放return 0;10_跨函数使用内存讲解及其示例CASE 1#includeint f();int main(void)int i=10;i=f();printf(“i=%dn”,i);for(i=0;i2000;+i)f();return 0;int f()int j=20;return j;C

14、ASE 2main ()int *p;fun(&p);.int fun (int *q)int s; /s为局部变量。调用完毕后s就没有了，最终p没有指向一个合法的整型单元*q=&s;CASE 3main()int *p;fun(&p);.int fun(int *q)*q=(int *)malloc(4);/返回4个字节，只取第1个字节地址赋给*q，*q=p。执行完后，因为没有free()，内存没有释放。如果没有free()，整个程序彻底终止时才能释放程序内部类定义方法A aa=new A();A *pa=(A*)malloc(sizeof(A);CASE 4#include#include

15、struct Studentint sid;int age;struct Student * CreatStudent(void);void ShowStudent(struct Student *);int main(void)struct Student *ps;ps=CreatStudent();ShowStudent(ps);return 0;struct Student * CreatStudent(void)struct Student *P=(struct Student *)malloc(sizeof(struct Student);p-sid=99;p-age=88;retu

16、rn p;void ShowStudent(struct Student *pst)printf(“%d %dn”,pst-sid,pst-age);11_复习12_连续存储数组的算法演示_113_连续存储数组的算法演示_2模块一：线性结构【把所有的结点用一根直线穿起来】1）连续存储数组2）离散存储链表线性结构的两种常见应用之一 栈线性结构的两种常见应用之二 队列专题：递归1. 1=2+3+4+.100的和2. 求阶乘3. 汉诺塔4. 走迷宫模块二：非线性结构树图连续存储数组1. 什么叫数组元素类型相同，大小相同2. 数组的优缺点：CASE 1#include#include/包含了mallo

17、c函数#include/包含了exit函数/定义了一个数据类型，该数据类型的名字叫做struct Arr,该数据类型含有3个成员，分别为pBase，len,cntstruct Arrint *pBase;/存储的是数组第一个元素的地址int len;/数组所能容纳的最大元素的个数int cnt;/当前数组有效元素的个数/int increment;/自动增长因子;void init_arr(struct Arr *pArr,int length);/初始化,使pBase指向一个有效的数组，而不再是垃圾数字bool append_arr(struct Arr *pArr,int val);/追加

18、，可能成功，可能失败bool insert_arr(struct Arr *pArr,int pos,int val);/pos的值从1开始bool delete_arr(struct Arr *pArr,int pos,int *pVal);int get();bool is_empty(struct Arr *pArr);/是否已满bool is_full(struct Arr *pAr);/是否为空void sort_arr(struct Arr *pArr);/排序void show_arr(struct Arr *pArr);/显示,分号不能省void innversion_arr(

19、struct Arr *pArr);/倒置int main (void)struct Arr arr; /只定义没初始化时，内部三个变量里都是垃圾数字int val;int posi=2;int len=6;/init_arr(arr);/会输出垃圾数字，并不能改变arr的值/printf(%dn,arr.len);init_arr(&arr,len);/会输出垃圾数字，并不能改变arr的值show_arr(&arr);append_arr(&arr,1);append_arr(&arr,-3);append_arr(&arr,6);append_arr(&arr,45);append_arr

20、(&arr,13);if(append_arr(&arr,34)printf(追加成功！n);else printf(追加失败！n);printf(追加之后的数组内容是:n);show_arr(&arr);if(delete_arr(&arr,posi,&val)printf(删除成功！n);printf(删除的元素是第%d个元素n,posi);printf(删除的元素是：%dn,val);elseprintf(删除失败！n);/*append_arr(&arr,1);append_arr(&arr,2);append_arr(&arr,3);append_arr(&arr,4);append

21、_arr(&arr,5);insert_arr(&arr,1,99);/pos的值从1开始*/*append_arr(&arr,6);append_arr(&arr,7); show_arr(&arr);if(append_arr(&arr,8)printf(追加成功！n);else printf(追加失败！n);*/printf(删除之后的数组内容是:n);show_arr(&arr);innversion_arr(&arr);/倒置printf(倒置之后的数组内容是:n);show_arr(&arr);sort_arr(&arr);printf(排序之后的数组内容是:n);show_arr

22、(&arr);return 0;void init_arr(struct Arr *pArr,int length)/(*pArr).len=99;pArr-pBase = (int*)malloc(sizeof(int)*length);if(NULL=pArr-pBase)printf(动态内存分配失败！n);exit(-1);/终止整个程序elsepArr-len=length;pArr-cnt=0;return;bool is_empty(struct Arr *pArr)/是否已满if(0=pArr-cnt)return true;else return false;void sho

23、w_arr(struct Arr *pArr)/显示/if(数组为空)/提示用户数组为空/else/输出数组有效内容if(is_empty(pArr)/printf(数组为空!n);elsefor(int i=0;icnt;i+)printf(%d ,pArr-pBasei);printf(n);bool is_full(struct Arr *pArr)/是否为空if(pArr-cnt=pArr-len)return true;elsereturn false;bool append_arr(struct Arr *pArr,int val)/追加，可能成功，可能失败/满时返回falseif

24、(is_full(pArr)return false;/不满时追加pArr-pBasepArr-cnt=val;(pArr-cnt)+;return true;bool insert_arr(struct Arr *pArr,int pos,int val)/pos的值从1开始int i;if(is_full(pArr)return false;if(pospArr-cnt+1)/return false;for (i=pArr-cnt-1;i=pos-1;-i)pArr-pBasei+1=pArr-pBasei; /i赋给i+1pArr-pBasepos-1=val;pArr-cnt+;re

25、turn true;bool delete_arr(struct Arr *pArr,int pos,int *pVal)int i;if(is_empty(pArr)return false;if(pospArr-cnt)return false;*pVal=pArr-pBasepos-1;for(i=pos;icnt;+i)pArr-pBasei-1=pArr-pBasei;pArr-cnt-;return true;void innversion_arr(struct Arr *pArr)/倒置int i=0;int j=pArr-cnt-1;int t;while(ipBasei;pA

26、rr-pBasei=pArr-pBasej;pArr-pBasej=t;+i;-j;return;void sort_arr(struct Arr *pArr)/排序int i,j,t;for(i=0;icnt;+i)for(j=i+1;jcnt;+j)if(pArr-pBaseipArr-pBasej)t=pArr-pBasei;pArr-pBasei=pArr-pBasej;pArr-pBasej=t;14_链表的重要性15_typedef的用法CASE 1#includetypedefint ZHAGNSAN;/为int再重新多取一个名字，ZHAGNSAN等价于inttypedef st

27、ruct Studentint sid;char name100;char sex;ST;int main(void)int i=10;/等价于ZHANGSAN i=10;/ZHAGNSAN j=20;/printf(%dn,j);struct Student st;/等价于ST st；struct Student *ps=&st;/等价于ST *ps;ST st2;st2.sid=200;printf(%dn,st2.sid);return 0;CASE 2#includetypedefint ZHAGNSAN;/为int再重新多取一个名字，ZHAGNSAN等价于inttypedef str

28、uct Studentint sid;char name100;char sex;*PST;/PST等价于struct Student *int main(void)struct Student st;/等价于ST st；PST ps=&st;ps-sid=99;printf(%dn,ps-sid);return 0;CASE 3#includetypedefint ZHAGNSAN;/为int再重新多取一个名字，ZHAGNSAN等价于inttypedef struct Studentint sid;char name100;char sex;*PSTU,STU;/PSTU等价于struct

29、Student *,STU代表了struct Studentint main(void)STU st;/相当于struct Srudent st;PSTU ps=&st;/相当于struct Srudent *ps=&st;ps-sid=99;printf(%dn,ps-sid);return 0;16_链表的定义定义：n个节点离散分配；彼此通过指针相连；每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。专业术语：首节点：第一个有效节点尾节点：最后一个有效节点头节点：头节点的数据类型和首节点的数据类型相同。第一个有效节点之前的那个节点；头节点并不存放存放有效数据；加头节点的目主

30、要是为了方便对链表的操作。头指针：指向头节点的指针变量尾指针：指向尾节点的指针变量头节点-首节点。尾节点【头节点并没有存储有效数据，也没有存放链表中有效节点的个数。首节点开始存放有效数据。在链表前边加一个没有实际意义的头节点，可以方便对链表的操作。头节点于之后节点的数据类型相同】分类：算法：链表的优缺点：17_如果希望通过一个函数来对链表进行处理，我们至少需要接受链表的哪些参数如果希望通过一个函数来对链表进行处理，我们至少需要接受链表的哪些参数只需要一个参数：头指针因为我们通过头指针可以推算出链表的其他所有参数18_每一个链表节点的数据类型该如何表示的问题CASE 1#includetyped

31、ef struct Nodeint data;/数据域struct Node * pNext;/指针域NODE,*PNODE;/NODE等价于struct Node，PNODE等价于struct Node *int main(void)return 0;19_链表的分类分类：单链表：每个链表的指针域只能指向后面的节点双链表：每一个节点有两个指针域循环链表：能通过任何一个节点找到其他所有的结点非循环链表：20_非循环单链表插入节点伪算法讲解算法：遍历查找清空销毁求长度排序删除节点插入节点插入算法1)r=p-pNext;p-Next=q;q-pNext=r;插入算法2)q-Next=p-pNext

32、;p-Next=q;【p，q不是节点，是指针变量】。21_删除非循环单链表节点伪算法的讲解删除算法1（不采用）：p-pNext=p-pNext-pNext;/容易导致内存泄露，没有释放内存算法2：先临时定义一个指向p后面节点的指针rr=p-pNext;p-pNext=p-pNext-pNext;free(r);22_学习数据结构的目的和要达到的要求23_复习24_链表创建和链表遍历算法的演示#include#include#includetypedef struct Nodeint data;/数据域struct Node * pNext;/指针域NODE,*PNODE;/NODE等价于str

33、uct Node，PNODE等价于struct Node */函数声明PNODE create_list(void);void traverse_list(PNODE pHead);int main(void)PNODE pHead=NULL;/等价于struct Node *pHead=NULL；pHead=create_list();/creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHeadtraverse_list(pHead);return 0;PNODE create_list(void)int len;/用来存放有效节点的个数int i;int v

34、al;/用来临时存放用户输入的节点的值/分配了一个不存放有效数据的头节点PNODE pHead=(PNODE)malloc(sizeof(NODE);if(NULL=pHead)printf(分配失败，程序终止！n);exit(-1);PNODE pTail=pHead;pTail-pNext=NULL;printf(请输入您需要生成的链表节点的个数：len=);scanf(%d,&len);for (i=0;idata=val;/挂pTail-pNext=pNew;pNew-pNext=NULL;pTail=pNew;return pHead;void traverse_list(PNODE

35、 pHead)PNODE p=pHead-pNext;while(NULL!=p)printf(%d ,p-data);p=p-pNext;/不连续，不能用p+printf(n);return;25_判断链表是否为空 和 求链表长度 算法的演示#include#include#includetypedef struct Nodeint data;/数据域struct Node * pNext;/指针域NODE,*PNODE;/NODE等价于struct Node，PNODE等价于struct Node */函数声明PNODE create_list(void);void traverse_li

36、st(PNODE pHead);bool is_empty(PNODE pHead);int length_list(PNODE);bool insert_list(PNODE,int,int);bool delete_list(PNODE,int,int*);void sort_list(PNODE);int main(void)PNODE pHead=NULL;/等价于struct Node *pHead=NULL；pHead=create_list();/creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHeadtraverse_list(pHead);i

37、nt len=length_list(pHead);printf(链表长度是%dn,len);if(is_empty(pHead)printf(链表为空！n);else printf(链表不空！n);return 0;PNODE create_list(void)int len;/用来存放有效节点的个数int i;int val;/用来临时存放用户输入的节点的值/分配了一个不存放有效数据的头节点PNODE pHead=(PNODE)malloc(sizeof(NODE);if(NULL=pHead)printf(分配失败，程序终止！n);exit(-1);PNODE pTail=pHead;p

38、Tail-pNext=NULL;printf(请输入您需要生成的链表节点的个数：len=);scanf(%d,&len);for (i=0;idata=val;/挂pTail-pNext=pNew;pNew-pNext=NULL;pTail=pNew;return pHead;void traverse_list(PNODE pHead)PNODE p=pHead-pNext;while(NULL!=p)printf(%d ,p-data);p=p-pNext;/不连续，不能用p+printf(n);return;bool is_empty(PNODE pHead)if(pHead-pNext

39、=NULL)return true;elsereturn false;int length_list(PNODE pHead)PNODE p=pHead-pNext;int len=0;while(NULL!=p)len+;p=p-pNext;return len;26_通过链表排序算法的演示 再次详细讨论到底什么是算法以及到底什么是泛型【重点】算法：狭义的算法是与数据的存储方式密切相关广义的算法是与数据的存储方式无关泛型：利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的#include#include#includetypedef struct Nodeint data;/数据

40、域struct Node * pNext;/指针域NODE,*PNODE;/NODE等价于struct Node，PNODE等价于struct Node */函数声明PNODE create_list(void);void traverse_list(PNODE pHead);bool is_empty(PNODE pHead);int length_list(PNODE);bool insert_list(PNODE,int,int);bool delete_list(PNODE,int,int*);void sort_list(PNODE);int main(void)PNODE pHea

41、d=NULL;/等价于struct Node *pHead=NULL；pHead=create_list();/creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHeadtraverse_list(pHead);int len=length_list(pHead);printf(链表长度是%dn,len);if(is_empty(pHead)printf(链表为空！n);else printf(链表不空！n);sort_list(pHead);traverse_list(pHead);return 0;PNODE create_list(void)int len

42、;/用来存放有效节点的个数int i;int val;/用来临时存放用户输入的节点的值/分配了一个不存放有效数据的头节点PNODE pHead=(PNODE)malloc(sizeof(NODE);if(NULL=pHead)printf(分配失败，程序终止！n);exit(-1);PNODE pTail=pHead;pTail-pNext=NULL;printf(请输入您需要生成的链表节点的个数：len=);scanf(%d,&len);for (i=0;idata=val;/挂pTail-pNext=pNew;pNew-pNext=NULL;pTail=pNew;return pHead;

43、void traverse_list(PNODE pHead)PNODE p=pHead-pNext;while(NULL!=p)printf(%d ,p-data);p=p-pNext;/不连续，不能用p+printf(n);return;bool is_empty(PNODE pHead)if(pHead-pNext=NULL)return true;elsereturn false;int length_list(PNODE pHead)PNODE p=pHead-pNext;int len=0;while(NULL!=p)len+;p=p-pNext;return len;void s

44、ort_list(PNODE pHead)int i,j,t;int len=length_list(pHead);PNODE p,q;for(i=0,p=pHead-pNext;ipNext)for(j=i+1,q=p-pNext;jpNext)if(p-dataq-data)/类似于数组中的：aiajt=p-data;/类似于数组中的：t=ai;p-data=q-data;/类似于数组中的：ai=aj;q-data=t;/类似于数组中的：aj=t;27_如何学习算法自己的一些感想28_链表插入和删除算法的演示#include#include#includetypedef struct No

45、deint data;/数据域struct Node * pNext;/指针域NODE,*PNODE;/NODE等价于struct Node，PNODE等价于struct Node */函数声明PNODE create_list(void);void traverse_list(PNODE pHead);bool is_empty(PNODE pHead);int length_list(PNODE);bool insert_list(PNODE,int,int);bool delete_list(PNODE,int,int*);void sort_list(PNODE);int main(v

46、oid)PNODE pHead=NULL;/等价于struct Node *pHead=NULL；int val;pHead=create_list();/creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHeadtraverse_list(pHead);int len=length_list(pHead);printf(链表长度是%dn,len);if(is_empty(pHead)printf(链表为空！n);else printf(链表不空！n);sort_list(pHead);traverse_list(pHead);insert_list(pHead

47、,4,33);traverse_list(pHead);if (delete_list(pHead,4,&val)printf(删除成功，您删除的元素是：%dn,val);elseprintf(删除失败！您删除的元素不存在!n);traverse_list(pHead);return 0;PNODE create_list(void)int len;/用来存放有效节点的个数int i;int val;/用来临时存放用户输入的节点的值/分配了一个不存放有效数据的头节点PNODE pHead=(PNODE)malloc(sizeof(NODE);if(NULL=pHead)printf(分配失败，

48、程序终止！n);exit(-1);PNODE pTail=pHead;pTail-pNext=NULL;printf(请输入您需要生成的链表节点的个数：len=);scanf(%d,&len);for (i=0;idata=val;/挂pTail-pNext=pNew;pNew-pNext=NULL;pTail=pNew;return pHead;void traverse_list(PNODE pHead)PNODE p=pHead-pNext;while(NULL!=p)printf(%d ,p-data);p=p-pNext;/不连续，不能用p+printf(n);return;bool

49、 is_empty(PNODE pHead)if(pHead-pNext=NULL)return true;elsereturn false;int length_list(PNODE pHead)PNODE p=pHead-pNext;int len=0;while(NULL!=p)len+;p=p-pNext;return len;void sort_list(PNODE pHead)int i,j,t;int len=length_list(pHead);PNODE p,q;for(i=0,p=pHead-pNext;ipNext)for(j=i+1,q=p-pNext;jpNext)if(p-dataq-data)/类似于数组中的：aiajt=p-data;/类似于数组中的：t=ai;p-data=q-data;/类似于数组中的：ai=aj;q-data=t;/类似于数组中的：aj=t;/在pHead所指向链表的第pos个节点的前面插入一个新的节点，新节点的值是val，并且pos的值是从1开始bool insert_list(PNODE pHead,int pos,int val)int i=0;PNODE p=pH