国嵌数据结构视频笔记

本节知识点：

1.数据之间的逻辑结构：
   集合结构：数据元素之间没有特别的关系，仅同属相同集合
   线性结构：数据元素之间是一对一的关系
   树形结构：数据元素之间存在一对多的层次关系
   图形结构：数据元素之间是多对多的关系
2.数据之间的物理结构
    顺序存储结构：将数据存储在地址连续的存储单元里
    链式存储结构：将数据存储在任意的存储单元里，通过保存地址的方式找到相关的数据元素
3.数据结构是相互之间存在一种或多种特定关系的数据元素的集合
4.程序 = 数据结构 + 算法
5.大O表示法：算法效率严重依赖于操作数量，首先关注操作数的最高次项，操作数的估计可以作为时间和空间复杂度的估算，在没有特殊说明的时候，我们应该分析复杂度的最坏情况
6.常见的复杂度类型：
大小关系：
7.线性表是零个或多个数据元素的集合，之间的元素是有顺序的，个数是有限的，数据类型必须相同。线性表包含两种存储方式，一种是顺序表，另一种链表。
8.对于线性表的使用是这样的：应该是在设计算法的时候，考虑算法中使用的数据，这些数据之间是什么关系的，如果是符合线性表特质的，就选择线性表作为数据结构。
9.顺序表与数组的关系：其实顺序表就是在数组的基础上构建的，本质跟数组是一样的，只是在数组的基础上增加了length长度，capacity容量等特性，然后补充了一些列，增、删、改、查的功能。
10. 我觉得链表比顺序表最大的优势，就在于链表的删除和插入要比顺序表简单的多，而且当线性表长度很大的时候很难开辟出整段的连续空间！！！最重要的是顺序表在创建的时候长度就固定了，再也改变不了了，而链表则可以根据情况动态增加，这一点是顺序表无论怎么样都不可能实现的！！！
 
顺序表的优点是：无需为线性表中的逻辑增加额外的空间，可以快速的通过下标的方式找到表中的合法位置。
11.线性表的常用操作：创建线性表、销毁线性表、清空线性表、将元素插入线性表、将元素从线性表中删除、获取线性表中某个位置的元素、获取线性表的长度

本节代码：

1.本节的代码是一个可以适合各种类型的顺序表，之所以能够适合各种类型，是因为它在顺序表中保存的是元素的地址(其实就是一个指针数组)。
2.代码中的描述顺序表的结构体中的元素介绍：length是顺序表中有元素的个数、capacity是顺序表的容量、node是顺序表的头地址(也是这个指针数组的头地址)、还有一个就是pos，pos是在删除和插入的时候使用的一个参数，它代表的是插入到顺序表位置的下标(数组的下标 是从0开始的 这个很要注意)。顺序表中有length个元素 下标是从0到length-1的。要注意的是 操作顺序表不同功能函数的pos的允许范围是不一样的。
3.本节代码对于函数参数的合法性判断是极其重视的，这个规范是值得学习的。
4.本节代码中对于顺序表的操作函数，凡是外界输入的，和输出到外界的，都是void *类型的，这样就保证了只有在这些操作函数中才能去改变   描述顺序表的结构体里面的值，在其他文件的函数中接受到的都是void *类型，无法直接给这个结构体中的值进行改变，这样的封装，保证了代码的安全性。
5.对于本节代码最值得思考的地方，常见的顺序表是typedef一个A类型，然后在顺序表中定义一个这个A类型的数组和length顺序表元素个数，这个顺序表中是好多个A类型的顺序集合，占用空间的大小是sizeof(A)*capacity。而本节的顺序表中是好多个unsigned int *地址类型的顺序集合，表中只有地址，第一节省了顺序表的空间，第二这样可以变相的保存不同类型的数据，第三它实现了 顺序表(即数据结构) 和 我们打算利用的数据(即元素)的分离。例如：linux内核链表(一个双向循环链表)就是一套单独的链表体制，这个链表用在很多机制上面，它就是变相的存储了好多类型的数据，并且实现了链表和数据的分离。
所以在main.c中  数据要想保存在这个顺序表中  就应该先给这些数据开辟内存    因为顺序表中没有他们呆的地方   顺序表中只能保存他们的地址。
如图：
代码如下：
Seqlist.c：
[cpp] view plaincopy
  1. /************************************************************************************  
  2. 文件名：Seqlist.c 
  3. 头文件：Seqlist.h  
  4. 时间： 2013/08/05  
  5. 作者： Hao  
  6. 功能：可以复用 带有增 删 改 查 功能的顺序表 
  7. 难点：1.顺序表中存放的都是 各种数据的地址 
  8.       2.void *是用来隔离封装用的 保证顺序表结构体只能被特定的函数改变                                                                                                                                  
  9. ************************************************************************************/  
  10. #include <stdio.h>  
  11. #include <malloc.h>  
  12. #include "Seqlist.h"  
  13.   
  14. typedef unsigned int TSeqListNode;//这个顺序表中存放的是 各种数据的地址 所以用unsigned int   
  15. typedef struct str_SeqList  
  16. {  
  17.     int length;//顺序已用的长度   
  18.     int capacity;//顺序表的总容量   
  19.     TSeqListNode* node;//这个指针是用来在顺序表中游走读取数据用的   
  20. }TSeqList;  //定义描述顺序表的结构体   
  21.   
  22. /************************************************************************************  
  23. 函数名：   Creat_SeqList 
  24. 函数功能： 创建一个容量为capacity的顺序表  
  25. 参数：     int capacity 创建顺序表中成员的个数 即顺序表容量 
  26. 返回值：   void* ret 如果返回NULL 说明创建顺序表失败 
  27.                      如果返回ret 说明创建顺序表成功  且ret为描述顺序表的结构体  
  28. ************************************************************************************/  
  29. SeqList* Creat_SeqList(int capacity)  
  30. {  
  31.     TSeqList* ret = NULL;  
  32.     /*进入函数 第一点是先判断传人参数的合法性*/  
  33.     if(capacity >= 0)  
  34.     {  
  35.         /*给顺序表开辟空间*/  
  36.         ret=(TSeqList* )malloc(sizeof(TSeqList)+sizeof(TSeqListNode)*capacity);  
  37.         if(NULL!=ret)//空间开辟成功   给描述顺序表的结构体 赋值   
  38.         {  
  39.             ret->capacity=capacity;  
  40.             ret->length=0;  
  41.             ret->node=(TSeqListNode* )(ret+1);//把真正顺序表的地址赋给 node   
  42.         }  
  43.     }  
  44.     else  
  45.     {  
  46.         ret = NULL;  
  47.     }   
  48.     return (SeqList*)(ret);  
  49. }   
  50.   
  51. /************************************************************************************  
  52. 函数名：   Destroy_SeqList 
  53. 函数功能： 销毁顺序表   free开辟的内存  
  54. 参数：     void* list 描述顺序表结构体指针 
  55. 返回值：   void  
  56. ************************************************************************************/  
  57. void  Destroy_SeqList(SeqList* list)  
  58. {  
  59.     free(list);  
  60. }  
  61.   
  62. /************************************************************************************  
  63. 函数名：  Get_Seqlist_Length 
  64. 函数功能：获得顺序表 现在的大小 
  65. 函数参数：void* list 描述顺序表结构体指针 
  66. 函数返回值：int ret  成功返回length 
  67.                      失败返回-1  
  68. ************************************************************************************/  
  69. int Get_Seqlist_Length(SeqList* list)  
  70. {  
  71.     int ret;  
  72.     TSeqList *Tlist=(TSeqList* )list;  
  73.     /*函数参数合法性检测*/  
  74.     if(NULL != Tlist)  
  75.     {  
  76.         ret=Tlist->length;  
  77.     }   
  78.     else  
  79.         ret=-1;  
  80.     return ret;  
  81. }  
  82.   
  83. /************************************************************************************ 
  84. 函数名：  Get_Seqlist_Capacity 
  85. 函数功能：获得顺序表 的容量  
  86. 函数参数：void* list 描述顺序表结构体指针 
  87. 函数返回值：int ret  成功返回capacity  
  88.                      失败返回-1  
  89. ************************************************************************************/  
  90. int Get_Seqlist_Capacity(SeqList* list)  
  91. {  
  92.     int ret;  
  93.     TSeqList *Tlist=(TSeqList* )list;  
  94.     /*函数参数合法性检测*/  
  95.     if(NULL != Tlist)  
  96.     {  
  97.         ret = Tlist->capacity;  
  98.     }   
  99.     else  
  100.         ret=-1;  
  101.     return ret;  
  102. }  
  103.   
  104. /************************************************************************************  
  105. 函数名：  Clean_Seqlist_Length 
  106. 函数功能：清空顺序表  其实就是给length=0；  
  107. 函数参数：void* list 描述顺序表结构体指针 
  108. 函数返回值：int ret  成功返回0 
  109.                      失败返回-1  
  110. ************************************************************************************/  
  111. int Clean_Seqlist_Length(SeqList* list)  
  112. {  
  113.     int ret;  
  114.     TSeqList *Tlist=(TSeqList* )list;  
  115.     /*函数参数合法性检测*/  
  116.     if(NULL != Tlist)  
  117.     {  
  118.         Tlist->length=0;  
  119.         ret=0;  
  120.     }   
  121.     else  
  122.         ret=-1;  
  123.     return ret;  
  124. }  
  125.   
  126. /************************************************************************************ 
  127. 函数名：  Seqlist_Add 
  128. 函数功能：顺序表中有length个数据  在下标为pos的位置上 插入数据node  所以pos是从0开始的 length是从1开始的  
  129. 参数:      SeqList* list描述顺序表的结构体地址   SeqListNode* node插入顺序表的数据的地址   
  130.            int pos插入顺序表的位置   pos的范围是从0(此时在顺序表头部插入)开始  到length(此时就是在顺序尾部插入) 
  131.             总共是length+1个位置  
  132. 返回值 ：  返回1 说明插入数据成功  返回0 说明插入数据失败 
  133. ************************************************************************************/  
  134. int Seqlist_Add(SeqList* list, SeqListNode* node ,int pos)  
  135. {  
  136.     /*参数合法性检测*/  
  137.     TSeqList *Tlist=(TSeqList* )list;  
  138.     int ret = (NULL != list);  
  139.     int i;  
  140.     ret=ret && (pos >= 0);  
  141.     ret=ret && (Tlist->length+1 <= Tlist->capacity);  //判断再插入一个数据的时候  length有没有超过 capacity   
  142.     if(1 == ret)  
  143.     {  
  144.         if(pos >= Tlist->length)//如果插入的位置pos比 length大的话 默认把length+1赋值给pos   
  145.         {  
  146.             pos = Tlist->length;  
  147.         }  
  148.         for(i=Tlist->length;i>pos;i--)  
  149.         {  
  150.             Tlist->node[i]=Tlist->node[i-1];  
  151.         }   
  152.         Tlist->node[i]=(TSeqListNode)node; //把要插入的地址强制类型转换成 unsigned int*   
  153.         Tlist->length++;  
  154.     }   
  155.     return ret;//返回1 说明插入数据成功  返回0 说明插入数据失败   
  156. }     
  157.   
  158.    
  159. /************************************************************************************ 
  160. 函数名：   Get_Node 
  161. 函数功能：找到顺序表中下标为pos的值   
  162. 参数：    pos插入顺序表的下标   pos的范围是从0到length-1    
  163.           SeqList* list描述顺序表的结构体地址 
  164. 返回值：  void* ret 找到pos为下标的那个值 
  165.         如果成功返回pos为下标的那个值   如果失败  返回NULL 
  166. ************************************************************************************/  
  167.   
  168. SeqListNode* Get_Node(SeqList* list, int pos)  
  169. {  
  170.     TSeqList* Tlist=(TSeqList* )list;  
  171.     SeqListNode* ret=NULL;  
  172.     if( (NULL!=Tlist) && (pos>=0) && (pos<Tlist->length) )  
  173.     {  
  174.         ret=(SeqListNode* )Tlist->node[pos]; //强制类型转换成void*    
  175.     }  
  176.     return ret;  
  177. }   
  178.   
  179. /************************************************************************************ 
  180. 函数名：   Del_Node 
  181. 函数功能：找到顺序表中下标为pos的值  并且删除它  
  182. 参数：    删除pos为下标的值   pos的范围是从0到length-1    
  183.           SeqList* list描述顺序表的结构体地址 
  184. 返回值：  void* ret  
  185.           如果成功返回pos为下标的那个值   如果失败  返回NULL  
  186. ************************************************************************************/  
  187. SeqListNode* Del_Node(SeqList* list, int pos)  
  188. {  
  189.     TSeqList* Tlist=(TSeqList* )list;  
  190.     SeqListNode* ret=NULL;  
  191.     int i;  
  192.     if( (NULL!=Tlist) && (pos>=0) && (pos<Tlist->length) )  
  193.     {  
  194.         ret=(SeqListNode* )Tlist->node[pos];  
  195.         for(i=pos+1; i<Tlist->length; i++)  
  196.         {  
  197.             Tlist->node[i-1]=Tlist->node[i];  
  198.         }  
  199.         Tlist->length--;  
  200.     }  
  201.     return ret;  
  202. }  

Seqlist.h：
[cpp] view plaincopy
  1. #ifndef __Seqlist__  
  2. #define __Seqlist__  
  3.   
  4. typedef void SeqList;  //是用来封装 使顺序表结构体 不被外界改变 只可被Seqlist.c文件中的函数改变  
  5.                        //因为 这些函数 对外的接口 都是void*    
  6. typedef void SeqListNode;//SeqList 是用来表示 顺序表的    SeqListNode是用来表示顺序表 中变量的   
  7.   
  8. SeqList* Creat_SeqList(int capacity);  
  9. void  Destroy_SeqList(SeqList* list);  
  10. int Get_Seqlist_Length(SeqList* list);  
  11. int Get_Seqlist_Capacity(SeqList* list);  
  12. int Clean_Seqlist_Length(SeqList* list);  
  13. int Seqlist_Add(SeqList* list, SeqListNode* node ,int pos);  
  14. SeqListNode* Get_Node(SeqList* list, int pos);  
  15. SeqListNode* Del_Node(SeqList* list, int pos);   
  16.   
  17. #endif  

main.c：
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "Seqlist.h"  
  4. int main(int argc, char *argv[])  
  5. {  
  6.     SeqList* My_SeqList = NULL;  
  7.     int a = 10;  
  8.     int b = 5;  
  9.     int c = 3;  
  10.     int d = 6;  
  11.     int e = 1;  
  12.     int *p = NULL;  
  13.     int i = 0;  
  14.     My_SeqList = Creat_SeqList(5);  
  15.     if( NULL != My_SeqList )  
  16.     {  
  17.             Seqlist_Add(My_SeqList, &a ,0);  
  18.             Seqlist_Add(My_SeqList, &b ,0);  
  19.             Seqlist_Add(My_SeqList, &c ,0);  
  20.             Seqlist_Add(My_SeqList, &d ,0);  
  21.             Seqlist_Add(My_SeqList, &e ,0);  
  22.               
  23.             for(i=0; i<Get_Seqlist_Length(My_SeqList); i++)  
  24.             {  
  25.                 p=Get_Node(My_SeqList, i);  
  26.                 printf("%d\n",*p);  
  27.             }  
  28.               
  29.             Del_Node(My_SeqList, 3);  
  30.             for(i=0; i<Get_Seqlist_Length(My_SeqList); i++)  
  31.             {  
  32.                 p=Get_Node(My_SeqList, i);  
  33.                 printf("%d\n",*p);  
  34.             }  
  35.               
  36.     }   
  37.     Clean_Seqlist_Length(My_SeqList);  
  38.     Destroy_SeqList(My_SeqList);  
  39.     return 0;  
  40. }  


test_main.c:
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #include "Seqlist.h"  
  5.   
  6. typedef struct student  
  7. {  
  8.     int student_num;  
  9.     char name[30];  
  10.     char sex[20];  
  11.     int age;  
  12. }str;  
  13. int main()  
  14. {  
  15.     str* str1;  
  16.     SeqList* slist=NULL;  
  17.     int i=0;  
  18.     int age=0;  
  19.     slist=Creat_SeqList(50);  
  20.     if(NULL == slist)  
  21.     {  
  22.         printf("malloc error!!!\n");  
  23.         return -1;  
  24.     }  
  25.     for(i=0; i<3; i++)  
  26.     {  
  27.         put_student(slist, str1);  
  28.     }  
  29.       
  30.     printf("输入你要删除的年龄：\n");  
  31.     scanf("%d",&age);  
  32.     printf("\n");  
  33.     find_student(slist, str1, age);  
  34.     get_student(slist, str1);  
  35.       
  36.     destroy_student(slist, str1);  
  37.     Clean_Seqlist_Length(slist);  
  38.     Destroy_SeqList(slist);  
  39.     return 0;  
  40. }  
  41.   
  42. int put_student(SeqList* slist, str* str1)  
  43. {   
  44.     int num;  
  45.     int ret=(NULL != str1);  
  46.     if(1 == ret)  
  47.     {  
  48.         ret=ret && Seqlist_Add(slist, (str* )malloc(sizeof(str)*1) ,50);  
  49.         num = Get_Seqlist_Length(slist);  
  50.         str1 = (str* )Get_Node(slist, num-1);  
  51.         printf("请输入学生学号：\n");   
  52.         scanf("%d",&str1->student_num);  
  53.         printf("请输入学生姓名：\n");  
  54.         scanf("%s",str1->name);  
  55.         printf("请输入学生性别：\n");  
  56.         scanf("%s",str1->sex);  
  57.         printf("请输入学生年龄：\n");  
  58.         scanf("%d",&str1->age);  
  59.         printf("\n");   
  60.     }         
  61.     else  
  62.     {  
  63.         ret = 0;  
  64.     }  
  65.     return ret;  
  66. }  
  67.   
  68. int get_student(SeqList* slist, str* str1)  
  69. {  
  70.     int ret=(NULL != str1);  
  71.     int i=0;  
  72.     if(1 == ret)  
  73.     {  
  74.         for(i=0; i<Get_Seqlist_Length(slist); i++)  
  75.         {  
  76.             str1 = (str*)Get_Node(slist, i);  
  77.             printf("学生学号：%d\n",str1->student_num);  
  78.           
  79.             printf("学生姓名：%s\n",str1->name);  
  80.               
  81.             printf("学生性别：%s\n",str1->sex);  
  82.               
  83.             printf("学生年龄：%d\n",str1->age);  
  84.         }  
  85.     }         
  86.     else  
  87.     {  
  88.         ret = 0;  
  89.     }  
  90.     return ret;  
  91. }  
  92.   
  93. int destroy_student(SeqList* slist, str* str1)  
  94. {  
  95.     int ret=(NULL != str1);  
  96.     int i=0;  
  97.     if(1 == ret)  
  98.     {  
  99.         for(i=0; i<Get_Seqlist_Length(slist); i++)  
  100.         {  
  101.             str1 = (str*)Get_Node(slist, i);  
  102.             free(str1);  
  103.         }  
  104.     }         
  105.     else  
  106.     {  
  107.         ret = 0;  
  108.     }  
  109.     return ret;  
  110. }  
  111.   
  112. int find_student(SeqList* slist, str* str1, int age)  
  113. {  
  114.     int ret=(NULL != str1);  
  115.     int i=0;  
  116.     int num=0;  
  117.     if(1 == ret)  
  118.     {  
  119.         num=Get_Seqlist_Length(slist);  
  120.         for(i=0; i<num; i++)  
  121.         {  
  122.             str1 = (str*)Get_Node(slist, i);  
  123.             if(str1->age == age)  
  124.             {  
  125.                 Del_Node(slist, i);  
  126.                 num=Get_Seqlist_Length(slist);  
  127.                 i--;  
  128.             }  
  129.         }  
  130.     }         
  131.     else  
  132.     {  
  133.         ret = 0;  
  134.     }  
  135.     return ret;  
  136. }  

test_main.c:
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #include "Seqlist.h"  
  5.   
  6. typedef struct student  
  7. {  
  8.     int student_num;  
  9.     char name[30];  
  10.     char sex[20];  
  11.     int age;  
  12. }str;  
  13. int main()  
  14. {  
  15.     str* str1;  
  16.     SeqList* slist=NULL;  
  17.     int i=0;  
  18.     int age=0;  
  19.     slist=Creat_SeqList(50);  
  20.     if(NULL == slist)  
  21.     {  
  22.         printf("malloc error!!!\n");  
  23.         return -1;  
  24.     }  
  25.     for(i=0; i<3; i++)  
  26.     {  
  27.         put_student(slist, str1);  
  28.     }  
  29.       
  30.     printf("输入你要删除的年龄：\n");  
  31.     scanf("%d",&age);  
  32.     printf("\n");  
  33.     find_student(slist, str1, age);  
  34.     get_student(slist, str1);  
  35.       
  36.     destroy_student(slist, str1);  
  37.     Clean_Seqlist_Length(slist);  
  38.     Destroy_SeqList(slist);  
  39.     return 0;  
  40. }  
  41.   
  42. int put_student(SeqList* slist, str* str1)  
  43. {   
  44.     int num;  
  45.     int ret=(NULL != str1);  
  46.     if(1 == ret)  
  47.     {  
  48.         ret=ret && Seqlist_Add(slist, (str* )malloc(sizeof(str)*1) ,50);  
  49.         num = Get_Seqlist_Length(slist);  
  50.         str1 = (str* )Get_Node(slist, num-1);  
  51.         printf("请输入学生学号：\n");   
  52.         scanf("%d",&str1->student_num);  
  53.         printf("请输入学生姓名：\n");  
  54.         scanf("%s",str1->name);  
  55.         printf("请输入学生性别：\n");  
  56.         scanf("%s",str1->sex);  
  57.         printf("请输入学生年龄：\n");  
  58.         scanf("%d",&str1->age);  
  59.         printf("\n");   
  60.     }         
  61.     else  
  62.     {  
  63.         ret = 0;  
  64.     }  
  65.     return ret;  
  66. }  
  67.   
  68. int get_student(SeqList* slist, str* str1)  
  69. {  
  70.     int ret=(NULL != str1);  
  71.     int i=0;  
  72.     if(1 == ret)  
  73.     {  
  74.         for(i=0; i<Get_Seqlist_Length(slist); i++)  
  75.         {  
  76.             str1 = (str*)Get_Node(slist, i);  
  77.             printf("学生学号：%d\n",str1->student_num);  
  78.           
  79.             printf("学生姓名：%s\n",str1->name);  
  80.               
  81.             printf("学生性别：%s\n",str1->sex);  
  82.               
  83.             printf("学生年龄：%d\n",str1->age);  
  84.         }  
  85.     }         
  86.     else  
  87.     {  
  88.         ret = 0;  
  89.     }  
  90.     return ret;  
  91. }  
  92.   
  93. int destroy_student(SeqList* slist, str* str1)  
  94. {  
  95.     int ret=(NULL != str1);  
  96.     int i=0;  
  97.     if(1 == ret)  
  98.     {  
  99.         for(i=0; i<Get_Seqlist_Length(slist); i++)  
  100.         {  
  101.             str1 = (str*)Get_Node(slist, i);  
  102.             free(str1);  
  103.         }  
  104.     }         
  105.     else  
  106.     {  
  107.         ret = 0;  
  108.     }  
  109.     return ret;  
  110. }  
  111.   
  112. int find_student(SeqList* slist, str* str1, int age)  
  113. {  
  114.     int ret=(NULL != str1);  
  115.     int i=0;  
  116.     int num=0;  
  117.     if(1 == ret)  
  118.     {  
  119.         num=Get_Seqlist_Length(slist);  
  120.         for(i=0; i<num; i++)  
  121.         {  
  122.             str1 = (str*)Get_Node(slist, i);  
  123.             if(str1->age == age)  
  124.             {  
  125.                 Del_Node(slist, i);  
  126.                 num=Get_Seqlist_Length(slist);  
  127.                 i--;  
  128.             }  
  129.         }  
  130.     }         
  131.     else  
  132.     {  
  133.         ret = 0;  
  134.     }  
  135.     return ret;  
  136. }  

线性表有两种：一种是顺序存储的叫顺序表，上节已经说过了，另一种是链式存储的叫链表，本节说的是单链表，即单向链表(每个节点中只包含一个指针域)。

本节知识点：

1.链表的好处：对于动态链表，可以对未知数据量的数据进行存储。插入和删除比顺序表方便的多，不用大量移动。
   链表的缺点：除了数据信息，还需对额外的链表信息进行分配内存，占用了额外的空间。访问指定数据的元素需要顺序访问之前的元素。
2.链表的基本概念：
   链表头(表头节点)：链表中的第一个节点，包含指向第一个数据元素的指针以及链表自身的一些信息(即链表长度length)
   数据节点：链表中的代表数据元素的节点，包含指向下一个数据元素的指针和数据元素的信息
   尾节点：链表中的最后一个数据节点，其下一元素指针为空，表示无后继
3.对于本节的可复用单链表的设计想法是这样的：
   a. 可复用的顺序表中保存的是各个数据的地址，所以我最初想到的是在链表元素中也保存各个数据的地址：
                                    
     使用这样的结构，add是链表中保存的数据，其实就是想复用保存的各种类型的地址，add是一个unsigned int型，用来保存各种数据类型的地址，next是链表结构，用来指向链表元素的下一个链表元素的。
     b.但是这样的结构有一个问题，就是从使用的总空间(链表结构的空间+add中保存数据的空间)角度来看，add就是一个浪费空间的变量。因为在add中保存地址，为什么不强制类型成next的类型(此时next应该是链表第一个结构的类型)，直接使用这个地址把各种你想要存储的结构赋值给next，这样存储的各个结构就变成了，如图。
     
    c.但是把所有的类型都转换成链表第一个元素的指针类型 再赋值给next 显得程序很不规整，所以最好直接给链表一个结构，把这些结构类型都统一强制类型转换成这个链表的类型，如下：
    
[cpp] view plaincopy
  1. typedef struct Str_LinkList LinkListNode;  //这个结构体是链表的真身   
  2. struct Str_LinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  3. {                     //转换成(LinkListNode* )的时候  其实就是要开始对每个元素中的 LinkListNode进行赋值了   
  4.     LinkListNode* next;  
  5. };  
     把什么链表头啊，链表元素啊，想要连接进入这个链表的各种结构都强制类型成 LinkListNode*   但是要保证每个结构中都有LinkListNode* next 成员。
     d.最后一点，就有点接受不了，也是为了代码的整洁，提高可读性，使链表结构都规整到LinkListNode这个结构中去，便于对链表进行管理，比如说双向链表的前驱和后继。把每个类型中的LinkListNode* next 成员  变成LinkListNode node。这里面有一个很好的c语言技巧，就是这个LinkListNode node必须要放在每个结构中(如 str)的第一个元素位置，即node的地址就是结构体str的地址，因为只有这样了，在把str强制类型转换成 n=(LinkListNode* )str的时候，访问n->next才是访问str.node->next的值，因为两者地址相同，切记一定要放到第一个元素的位置！！！
4.对于链表这个数据结构，一定要注意一个问题，也是这节我犯的一个很难发现的错误：
   就是已经在链表中的元素，千万不要再一次往链表中进行插入，因为这样会导致从它插入的地方开始链表的后继就开始混乱了，把整个链表完全弄乱，出现你想不到的问题。

本节代码：

本节实现的是一个可以复用的单链表：
LinkList.c：
[cpp] view plaincopy
  1. /******************************************************************************************************* 
  2. 文件名：LinkList.c 
  3. 头文件：LinkList.h  
  4. 时间： 2013/08/07 
  5. 作者： Hao 
  6. 功能:  可以复用 带有增 删 改 查 功能的单链表 
  7. 难道： 1.typedef struct Str_LinkList LinkListNode;  //这个结构体是链表的真身  
  8.         struct Str_LinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型  
  9.         {                     //转换成(LinkListNode* )的时候  其实就是要开始对每个元素中的 LinkListNode进行赋值了  
  10.             LinkListNode* next; 
  11.         };  
  12.         这个链表结构在链表元素中起到的作用 是本节的难点  
  13.         2.切记一个问题  就是已经是链表中元素的 千万不要再往链表中添加了 否则链表一定出现无穷的错误  
  14.         3.对于pos值的问题  add、get、del三个函数中 的链表都是 从1开始的到length  0是链表头  
  15.                           在add函数中pos为0的时候是和pos为1的情况是一样的  都是头插法  0~~~~~无穷大  
  16.                           在get函数中pos为0的时候是获得链表头 地址      0~~~~~length  
  17.                           在del函数中pos为0的时候是无效的 del失败       1~~~~~length  
  18. *******************************************************************************************************/  
  19. #include <stdio.h>  
  20. #include <stdlib.h>  
  21. #include <malloc.h>  
  22. #include "LinkList.h"  
  23.   
  24. typedef struct str_list_head  //这个是链表头 其实也可以当作一个没有前驱的 链表元素 元素的内容是链表长度   
  25. {  
  26.     //LinkListNode* next;  
  27.     LinkListNode head; //这个参数要特别重视 每一个链表元素结构的第一个参数一定是 LinkListNode  
  28.                        //因为在寻找链表元素后继的时候 其实就是将链表元素强制类型转换成 LinkListNode*  然后给next进行赋值 其实就是给 LinkListNode变量赋值   
  29.     int length; //链表长度   
  30. }list_head;  
  31.   
  32. /******************************************************************************************************* 
  33. 函数名： Creat_LinkListHead 
  34. 函数功能：创建一个链表的链表头 并给链表头分配空间 
  35. 参数： void 
  36. 返回值：ret 成功返回链表头地址  失败返回NULL  
  37. *******************************************************************************************************/  
  38. LinkList* Creat_LinkListHead(void)  
  39. {  
  40.     list_head* ret = NULL;  
  41.     ret = (list_head* )malloc( sizeof(list_head)*1 );  
  42.     if(NULL != ret) //malloc分配成功   
  43.     {  
  44.         ret -> length = 0;  
  45.         //ret -> next = NULL;  
  46.         ret -> head.next = NULL;  
  47.     }  
  48.     return (LinkList* )ret;   
  49. }  
  50.   
  51. /******************************************************************************************************* 
  52. 函数名：Destroy_LinkListHead 
  53. 函数功能：释放一个链表头指针  
  54. 参数：LinkList* head 链表头指针  
  55. 返回值： ret 释放成功返回1  释放失败返回0  
  56. *******************************************************************************************************/  
  57. int Destroy_LinkListHead(LinkList* head)  
  58. {  
  59.     int ret = 0;   
  60.     list_head* lhead = (list_head* )head;  
  61.     if( NULL != lhead )  
  62.     {  
  63.         free(lhead);  
  64.         ret = 1;  
  65.     }  
  66.     return ret;  
  67. }  
  68.   
  69. /******************************************************************************************************* 
  70. 函数名:Get_Length 
  71. 函数功能：获得链表的长度  
  72. 参数: LinkList* head 链表头指针  
  73. 返回值： ret 成功返回链表长度  失败返回0  
  74. *******************************************************************************************************/  
  75. int Get_Length(LinkList* head)   
  76. {  
  77.     int ret = 0;  
  78.     list_head* lhead = (list_head* )head;  
  79.     if( NULL != lhead )  
  80.     {  
  81.         ret = lhead -> length;  
  82.     }     
  83.     return ret;  
  84. }  
  85.   
  86. /******************************************************************************************************* 
  87. 函数名：Clean_LinkListHead 
  88. 函数功能：   清空链表  
  89. 参数： LinkList* head 链表头指针  
  90. 返回值：ret 成功返回1 失败返回0  
  91. *******************************************************************************************************/  
  92. int Clean_LinkListHead(LinkList* head)   
  93. {  
  94.     int ret = 0;  
  95.     list_head* lhead = (list_head* )head;  
  96.     if( NULL != lhead )  
  97.     {  
  98.         lhead -> length = 0;  
  99.         //lhead -> next = NULL;  
  100.         lhead -> head.next = NULL;  
  101.         ret = 1;  
  102.     }     
  103.     return ret;  
  104. }  
  105.   
  106. /******************************************************************************************************* 
  107. 函数名:Add_LinkList 
  108. 函数功能：往链表里面添加一个链表元素 如果pos的值是0(就是链表头)和1(链表的第一元素 链表元素个数是从1开始算的)都是头插法 
  109.           pos的值大于链表长度是尾插法  这里面pos值得注意的是 i=1 pos为a的时候 是把链表元素插入第a个元素的位置  
  110.           当i=0 pos为a的时候 是把链表元素插入 第a个元素位置的后面    切忌：这里面0位置是链表头指针 从1开始是链表元素  
  111. 参数：   LinkList* head链表头指针    LinkListNode* Node插入元素的指针(被强制类型转化成LinkListNode*)  int pos 插入位置  
  112.          pos的有效值范围是 从0到无穷大   
  113. 返回值： ret 插入成功返回1  插入失败返回0  
  114. *******************************************************************************************************/  
  115. int Add_LinkList(LinkList* head, LinkListNode* Node, int pos)  
  116. {  
  117.     int ret = 0;  
  118.     int i = 0;  
  119.     list_head* lhead = (list_head* )head;  
  120.     LinkListNode* node = (LinkListNode* )head;  
  121.     ret=( NULL != node) && ( NULL != Node) && (pos >= 0);  
  122.     if(1 == ret)  
  123.     {  
  124.         for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  125.         {  
  126.             node = node->next;  
  127.         }  
  128.         Node -> next = node -> next;  
  129.         node -> next = Node;  
  130.           
  131.         lhead -> length++;   
  132.     }  
  133.     return ret;  
  134. }  
  135.   
  136. /******************************************************************************************************* 
  137. 函数名：Get_LinkListNode 
  138. 函数功能：获得链表中第pos个元素位置的链表元素 链表是从1开始的  0是链表头   pos为0的时候表示get链表头  
  139. 参数： LinkList* head链表头指针    int pos获得链表元素的位置  pos的有效取值范围是 1 到  length  0是链表头  
  140. 返回值： LinkListNode*类型 第pos个链表元素的地址  
  141. *******************************************************************************************************/  
  142. LinkListNode* Get_LinkListNode(LinkList* head, int pos)  
  143. {  
  144.     int ret = 0;  
  145.     int i = 0;  
  146.     list_head* lhead = (list_head* )head;  
  147.     ret=( NULL != lhead) && (pos >= 0) && (pos <= lhead->length);  
  148.     if(1 == ret)  
  149.     {  
  150.         LinkListNode* node = (LinkListNode* )head;  
  151.         for(i=0; i<pos; i++) //执行 pos次   得到的是第pos位置的node   
  152.         {  
  153.             node = node->next;  
  154.         }     
  155.         return (LinkListNode*)node;  
  156.     }  
  157.     return NULL;  
  158. }  
  159.   
  160. /******************************************************************************************************* 
  161. 函数名：Del_LinkListNode 
  162. 函数功能：删除链表中第pos位置的链表元素  
  163. 参数： LinkList* head链表头指针    int pos删除链表元素的位置  pos是删除的链表元素的位置 跟get和add中的 
  164.        pos是配套的  有效取值范围依然是 1到 length  在这个函数里面由于不能删除链表头 所以pos为0的时候无效  
  165. 返回值： LinkListNode* ret这个返回值很重要 因为这个删除仅仅是把链表元素踢出了链表 并没有free开辟的内存 
  166.          应该通过这个返回的地址free  释放内存 
  167.          删除成功返回 删除链表元素的地址   删除失败返回 NULL  
  168. *******************************************************************************************************/  
  169. LinkListNode* Del_LinkListNode(LinkList* head, int pos)  
  170. {  
  171.     LinkListNode* ret = NULL;  
  172.     int i = 0;  
  173.     list_head* lhead = (list_head* )head;  
  174.     if(( NULL != lhead) && (pos > 0) && (pos <= lhead->length))  
  175.     {  
  176.         LinkListNode* node = (LinkListNode* )head;  
  177.         for(i=1; i<pos; i++)//执行 pos次   得到的是第pos位置的node  这个方法行不通   
  178.         {                   //因为要想删除第pos位置的node 应该先找到它上一个链表元素   
  179.             node = node->next; //所以这里面i=1 比get函数少执行了一次  得到第pos-1位置的node   
  180.         }  
  181.         ret = node->next;  
  182.         node->next = ret->next;     
  183.           
  184.         lhead->length--;  
  185.     }  
  186.     return (LinkListNode*)ret;  
  187. }  

LinkList.h：
[cpp] view plaincopy
  1. #ifndef __LinkList_H__  
  2. #define __LinkList_H__  
  3.   
  4. typedef void LinkList;  //这个是为了 封装方便   
  5. typedef struct Str_LinkList LinkListNode;  //这个结构体是链表的真身   
  6. struct Str_LinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  7. {                     //转换成(LinkListNode* )的时候  其实就是要开始对每个元素中的 LinkListNode进行赋值了   
  8.     LinkListNode* next;  
  9. };  
  10.   
  11. LinkList* Creat_LinkListHead(void);  
  12.   
  13. int Destroy_LinkListHead(LinkList* head);  
  14.   
  15. int Get_Length(LinkList* head);  
  16.   
  17. int Clean_LinkListHead(LinkList* head);  
  18.   
  19. int Add_LinkList(LinkList* head, LinkListNode* Node, int pos);  
  20.   
  21. LinkListNode* Get_LinkListNode(LinkList* head, int pos);  
  22.   
  23. LinkListNode* Del_LinkListNode(LinkList* head, int pos);   
  24.    
  25. #endif  

main.c：
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #include <string.h>  
  5. #include "LinkList.h"  
  6.   
  7. typedef struct student  
  8. {  
  9.     //LinkListNode* next;  
  10.     LinkListNode node;  
  11.     int num;  
  12.     char name[30];  
  13. }str;  
  14. int main(int argc, char *argv[])   
  15. {  
  16.     str str1,str2,str3,str4,str5,str6,*strp;  
  17.     int i=0;  
  18.     LinkList* list_head;  
  19.     list_head = Creat_LinkListHead();  
  20.       
  21.     str1.num = 1;  
  22.     strcpy(str1.name,"haohao");  
  23.       
  24.     str2.num = 2;  
  25.     strcpy(str2.name,"ququ");  
  26.       
  27.     str3.num = 3;  
  28.     strcpy(str3.name,"popo");  
  29.       
  30.     str4.num = 4;  
  31.     strcpy(str4.name,"wowo");  
  32.       
  33.     str5.num = 5;  
  34.     strcpy(str5.name,"tiantian");  
  35.   
  36.     str6.num = 6;  
  37.     strcpy(str6.name,"cheche");  
  38.       
  39.     Add_LinkList(list_head, (LinkListNode*)&str1, 0);  
  40.     Add_LinkList(list_head, (LinkListNode*)&str2, 0);  
  41.     Add_LinkList(list_head, (LinkListNode*)&str3, 0);  
  42.     Add_LinkList(list_head, (LinkListNode*)&str4, 0);  
  43.     Add_LinkList(list_head, (LinkListNode*)&str5, 0);  
  44.     strp = (str*)Del_LinkListNode(list_head, 5);  
  45.     printf("%d\n",strp->num);  
  46.     printf("%s\n",strp->name);  
  47.     printf("\n");  
  48.     for(i=1; i<= Get_Length(list_head); i++)  
  49.     {  
  50.         strp = (str*)Get_LinkListNode(list_head, i);  
  51.         printf("%d\n",strp->num);  
  52.         printf("%s\n",strp->name);  
  53.     }   
  54.     printf("\n");  
  55.     Add_LinkList(list_head, (LinkListNode*)&str6, 3);     
  56.     for(i=1; i<= Get_Length(list_head); i++)  
  57.     {  
  58.         strp = (str*)Get_LinkListNode(list_head, i);  
  59.         printf("%d\n",strp->num);  
  60.         printf("%s\n",strp->name);  
  61.     }   
  62.           
  63.       
  64.     Clean_LinkListHead(list_head);  
  65.     Destroy_LinkListHead(list_head);  
  66.     return 0;  
  67. }  

课后练习：

1.对于上节顺序表中的unsigned  int型保存数据地址，可不可用void*   
这个问题已经得到了唐老师的解答，其实使用void* 最好了，因为使用unsigned int  仅仅能够在32位机上面运行成功，在64位机上运行就会出错的！！！

2.对于有头链表和无头链表的区别
所谓有头链表，就是有头结点的链表，头结点是一个链表元素，但不存放数据。无头链表就是没有头结点的链表。相比之下有头链表比无头链表，方便很多，优点也很多。
无头链表就是在谭浩强老师的c语言书中的那个链表。就是没有头结点，只有一个指针指向链表第一个元素。这个指针被叫做链表头。      个人建议使用有头链表！！！
3.对顺序表和单链表添加一个反转操作
   a.对于顺序表 其实就是在不断的交换
   b.对于链表  我觉得还是使用双向链表吧，解决这个问题就方便了~~~




问题描述：假设有一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（不是第一个，也不是最后一个节点），请将该节点从单链表中删除。

一般链表的删除需要顺着头结点向下找到当前待删节点的前驱节点，然后让前驱节点指向后驱节点就行了。这里，没有头结点，就没办法找到前驱结点。但我们可以采用“狸猫换太子”的做法。我们把当前结点“看成”是前驱结点，把后续节点当做待删结点删除（删除之前，记下后续结点的值），只需要让当前结点指向后驱结点的后驱结点。最后把后续结点值赋给当前结点的值。

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include<assert.h>  
  4.   
  5. typedef struct node{  
  6.     int data;  
  7.     node *next;  
  8. }Node;  
  9.   
  10. void printlist(Node *head_ptr);  
  11. void delete_random_node(Node *current);  
  12.   
  13. int main(){  
  14.     Node n1, n2, n3;  
  15.     n1.data = 10;  
  16.     n1.next = &n2;  
  17.     n2.data = 20;  
  18.     n2.next = &n3;  
  19.     n3.data = 30;  
  20.     n3.next = NULL;  
  21.     printf("Before deleting\n");  
  22.     printlist(&n1);  
  23.     delete_random_node(&n2);  
  24.     printf("\nAfter deleting\n");  
  25.     printlist(&n1);  
  26.     return 0;  
  27. }  
  28.   
  29. void printlist(Node *head_ptr){    
  30.     Node *ptr = head_ptr;   
  31.     while(ptr != NULL){    
  32.         printf("%d    ", ptr->data);    
  33.         ptr = ptr->next;    
  34.     }    
  35.     printf("\n");    
  36. }    
  37.   
  38. void delete_random_node(Node *current){  
  39.     assert(current != NULL);  
  40.     Node *next = current->next;  
  41.     if(next != NULL){  
  42.         current->next = next->next;  
  43.         current->data = next->data;  
  44.     }  
  45. }  

扩展问题


编写一个函数，给定一个链表的头指针，要求只遍历一次，将单链表中的元素顺序反转过来。

[cpp] view plaincopy
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3.   
  4. typedef struct node{  
  5.     int data;  
  6.     node *next;  
  7. }Node;  
  8.   
  9. Node *reverse_linklist(Node *head);  
  10. void printlist(Node *ptr);  
  11.   
  12. int main(){  
  13.     Node n1, n2, n3;  
  14.     Node *head;  
  15.     head = (Node *)malloc(sizeof(Node));  
  16.     head->next = &n1;  
  17.     n1.data = 10;  
  18.     n1.next = &n2;  
  19.     n2.data = 20;  
  20.     n2.next = &n3;  
  21.     n3.data = 30;  
  22.     n3.next = NULL;  
  23.   
  24.     printf("Before reversing\n");  
  25.     printlist(head);  
  26.     printf("\nAftering reversing\n");  
  27.     printlist(reverse_linklist(head));  
  28.     return 0;  
  29. }  
  30.   
  31. void printlist(Node *head_ptr){  
  32.     Node *ptr = head_ptr->next;  
  33.     while(ptr != NULL){  
  34.         printf("%d    ", ptr->data);  
  35.         ptr = ptr->next;  
  36.     }  
  37.     printf("\n");  
  38. }  
  39.   
  40. Node *reverse_linklist(Node *head){  
  41.     Node *p = head->next;  
  42.     Node *e = NULL;  
  43.     Node *q;  
  44.     while(p->next != NULL){  
  45.         q = p->next;  
  46.         p->next = e;  
  47.         e = p;  
  48.         p = q;  
  49.     }  
  50.     p->next = e;  
  51.     head->next = p;  
  52.     return head;  
  53. }  






本节知识点：

1.静态链表到底是什么：链表就是链式存储的线性表，但是它分为动态和静态两种，所谓动态就是长度不固定，可以根据情况自行扩展大小的，静态链表就是长度大小固定的，链式存储的线性表。
2.本节的静态链表和顺序表很像(其实和数组也很像)，准确的来说就是利用顺序表实现的，只是这个顺序表，不是顺序排列的，是通过一个next变量，连接到下一个变量的。
如图：

3.唐老师说静态链表是在一些没有指针的语言中使用的，来实现链表的功能，但是我觉得链表的最大优势就在于它的伸缩，用多少开辟多少。但是静态链表就恰恰失去了这个优势。依我看，学习静态链表的目的是学习它这种类似内存管理的算法思想。
4.静态链表中值得学习的思想：就是在初始化链表的时候，把所以空间都标记成为可用-1，每次插入数据的时候，都在标记为可用的空间内挑取，再把-1改成next。当删除变量的时候在把next改成-1，标记为空间可用。
5.其实仔细想想 看看，静态链表只是一个思想，为什么这么说，首先在获取index的时候，你是顺序获取的，这导致你的next也是连续的，所以他其实就变成了一个顺序表。在这里我想到了一个唐老师的问题，为什么node[0]就可以当作头节点，还要再定义一个head变量。唐老师的解答是：顺序获得index的时候每次都要遍历太浪费时间了，所以最好应该在同一块空间再定义一个链表，来保存这些空闲空间，然后这样就需要两个链表的头节点了，所以需要一个head。然后让node[0]一会是空闲链表的链表头节点，一会是真实保存数据的链表的头节点。当插入的时候，只需要在那个空闲链表取空间就可以了，提高了算法的效率。
PS1：对于node[0]我真的想说，其实让node[0]当作头节点的使用真的很方便，比head方便很多，仅仅是个人体会。
PS2：对于两个链表的那个算法，我觉得如果还是顺序在链表中获得index，依然没有解决这个index是有顺序的且顺序是固定的问题。这里的顺序是指的是那个空闲链表的顺序。所以说这仅仅是一个思想。

6.本节最重要的知识点也是最大的难点：对于柔性数组的描述。
对于柔性数组的结构如下：
[cpp] view plaincopy
  1. typedef struct _tag_StaticList  //因为静态链表是基于顺序表改写的  这个就是顺序表中描述顺序表的那个结构   
  2. {  
  3.     int capacity;           //静态链表的大小是固定的  这是链表的容量   
  4.     StaticListNode head;    //链表  头节点    
  5.     StaticListNode node[];  //利用柔性数组 创建静态链表   
  6. }StaticList;  

然后：给柔性数组开辟空间
[cpp] view plaincopy
  1. StaticList* ret = NULL;   
  2. ret = (StaticList*)malloc( sizeof(StaticList)*1 + sizeof(StaticListNode)*(capacity+1) );  
其实柔性数组就是以数组的方式访问内存。对于 StaticList  ret这个结构体的大小是不包括StaticLIstNode node[]的，StaticLIstNode node[]是没有大小的，StaticLIstNode node[0]访问的内存是StaticList  ret这个结构体后面的第一个内存，StaticLIstNode node[1]访问的内存是StaticList  ret这个结构体后面的第二个内存等等。
PS：StaticLIstNode node[]这个结构到底是个什么结构，不好说，不是数组，也不是指针。就把它当作为了柔性数组而产生的结构吧！！！

本节代码：

StaticList.c：
[cpp] view plaincopy
  1. /**************************************************************************************************************  
  2. 文件名：StaticList.c 
  3. 头文件：StaticList.h 
  4. 时间：2013/08/15 
  5. 作者：Hao 
  6. 功能：可以复用的 带有增 删  改 查 的静态链表  
  7. **************************************************************************************************************/  
  8. #include <stdio.h>  
  9. #include <malloc.h>  
  10. #include <string.h>  
  11. #include "StaticList.h"  
  12.   
  13. #define AVAILABLE -1  
  14.   
  15. typedef struct _tag_StaticListNode  //这个是静态链表的结构   用来保存链表元素的   
  16. {  
  17.     unsigned int data;   //这个是为了复用  保存数据地址的   
  18.     int next;            //这个是用来保存下一个节点位置的   
  19. }StaticListNode;           
  20.   
  21. typedef struct _tag_StaticList  //因为静态链表是基于顺序表改写的  这个就是顺序表中描述顺序表的那个结构   
  22. {  
  23.     int capacity;           //静态链表的大小是固定的  这是链表的容量   
  24.     StaticListNode head;    //链表  头节点    
  25.     StaticListNode node[];  //利用柔性数组 创建静态链表   
  26. }StaticList;  
  27.   
  28. /**************************************************************************************************************  
  29. 函数名 ： Creat_StaticList 
  30. 函数功能：创建一个静态链表使用的空间 
  31. 具体数据： StaticList这个结构是描述静态链表的结构    StaticListNode这个结构才是真正的静态链表的元素 
  32.            每一个静态链表的元素都是由两个部分组成的 一个是数据data(即保存的地址)  另一个是下一个链表 
  33.            元素的位置next     
  34.            对于StaticList这个结构中的数据是capacity是静态链表的容量 head是链表的头节点 
  35.            node[0]也是头节点 node[]是柔性数据  这里面保存的才是真的链表内容  
  36. 参数： int capacity  链表容量  正确范围 0到无穷大  当为0的时候链表中仅仅有一个node[0]头节点  
  37. 返回值：StaticList* ret 返回描述静态链表的结构 StaticList的地址   (SList*这个是为了封装) 
  38. **************************************************************************************************************/   
  39. SList* Creat_StaticList(int capacity)  
  40. {  
  41.     int i=0;   
  42.     StaticList* ret = NULL;   
  43.     if( capacity >= 0) //参数合法性检测  一定要大于等于0   如果capacity为0 是给node[0]开辟空间  node[0]是链表头节点   
  44.     {  
  45.         ret = (StaticList*)malloc( sizeof(StaticList)*1 + sizeof(StaticListNode)*(capacity+1) );  
  46.     }  
  47.     if(NULL != ret)  //判断malloc是否成功 内存是否分配成功   
  48.     {  
  49.         ret -> capacity = capacity; //静态链表的容量   
  50.         ret -> head.data = 0;   //头节点中保存的 链表长度   初始化为0   
  51.         ret -> head.next = 0;   //头节点中保存的  链表下一个节点的位置  初始化为NULL  
  52.         for(i=1; i<=capacity; i++)  //把链表中从node[1]开始 到node[capacity]中的next都标志为可用   
  53.         {  
  54.             ret -> node[i].next =  AVAILABLE; //这个在插入函数的时候有用   
  55.         }   
  56.           
  57.     }  
  58.     return (SList*)ret;  
  59.        
  60. }   
  61.   
  62. /**************************************************************************************************************  
  63. 函数名：Destroy_StaticList 
  64. 函数功能：释放StaticList结构开辟的内存  
  65. 参数：StaticList* Static_List  (SList* Static_List这个是为了 封装) 
  66. 返回值：void  
  67. **************************************************************************************************************/   
  68. void Destroy_StaticList(SList* Static_List)  
  69. {  
  70.     free(Static_List); //释放静态链表创建的内存空间   
  71. }  
  72.   
  73. /************************************************************************************************************** 
  74. 函数名： Get_Lenth 
  75. 函数功能：返回静态链表长度 
  76. 参数：StaticList* Static_List    (SList* List为了封装) 
  77. 返回值：成功 int Static_List -> head.data 静态链表使用的长度   失败返回 0  
  78. **************************************************************************************************************/  
  79. int Get_Lenth(SList* List)   
  80. {  
  81.     StaticList* Static_List = (StaticList*)List;  
  82.     int ret = 0;  
  83.     if(NULL != Static_List)  
  84.     {  
  85.         ret = Static_List -> head.data; //静态链表的长度   
  86.     }  
  87.     return ret;  
  88. }  
  89.   
  90. /************************************************************************************************************** 
  91. 函数名：Get_Capacity 
  92. 函数功能：返回静态链表的容量 
  93. 参数：StaticList* Static_List  (SList* List为了封装) 
  94. 返回值：成功返回 int Static_List -> capacity 静态链表的容量  失败返回 0  
  95. **************************************************************************************************************/  
  96. int Get_Capacity(SList* List)   
  97. {  
  98.     StaticList* Static_List = (StaticList*)List;  
  99.     int ret = 0;  
  100.     if(NULL != Static_List)  
  101.     {  
  102.         ret = Static_List -> capacity; //静态链表的容量   
  103.     }  
  104.     return ret;  
  105. }  
  106.   
  107. /************************************************************************************************************** 
  108. 函数名： Clear_StaticList 
  109. 函数功能：重置静态链表 
  110. 参数：StaticList* Static_List  (SList* List为了封装) 
  111. 返回值：成功返回1  失败返回0  
  112. **************************************************************************************************************/  
  113. int Clear_StaticList(SList* List)  
  114. {  
  115.     StaticList* Static_List = (StaticList*)List;  
  116.     int i = 0;  
  117.     int ret = 0;  
  118.     if(NULL != Static_List)  
  119.     {  
  120.         Static_List -> head.data = 0;  
  121.         Static_List -> head.next = 0;  
  122.         for(i=1; i<=Static_List -> capacity; i++)    
  123.         {  
  124.             Static_List -> node[i].next =  AVAILABLE;    
  125.         }   
  126.         ret = 1;  
  127.     }   
  128.     return ret;  
  129. }  
  130.   
  131. /************************************************************************************************************** 
  132. 函数名： Add_StaticList 
  133. 函数功能： 在链表中的pos位置处插入一个链表元素   pos的规则跟上节单链表的规则一样 0和1为头插法  无穷大为尾插法 
  134.            node[0]是链表头节点  其实是head的一个中间变量  使用node[0]真的很方便 此处记得更新头节点 
  135. 参数：SList* List 要插入的链表地址    SListNode* Node要插入的数据地址   int pos插入的位置  
  136. 返回值：返回1说明插入成功  返回0说明插入失败  
  137. **************************************************************************************************************/  
  138. int Add_StaticList(SList* List, SListNode* Node, int pos)  
  139. {  
  140.     StaticList* Static_List = (StaticList*)List;  
  141.     StaticListNode*  node =  (StaticListNode*)Node;  
  142.     int ret = 0;  
  143.     int num = 0;  
  144.     int index = 0;  
  145.     int i = 0;  
  146.     ret = (NULL != Static_List)&&(NULL != node);  
  147.     ret = ret&&(Static_List->head.data+1 <= Static_List->capacity)&&(pos >= 0);   
  148.       
  149.     if(ret)  //参数合法性检测成功   
  150.     {  
  151.         for(i=1; i<=Static_List->capacity; i++) //轮询获得可用的位置index   
  152.         {  
  153.             if(-1 == Static_List->node[i].next)  
  154.             {  
  155.                 index = i;  
  156.                 break;  
  157.             }  
  158.         }  
  159.         Static_List->node[index].data = (unsigned int)node; //保存链表中的数据   
  160.         Static_List->node[0] = Static_List->head;  //此时node[0]变成了链表头节点   
  161.   
  162.         for(i=1; (i < pos)&&(0 != Static_List->node[num].next); i++)  
  163.         {  
  164.             num =  Static_List->node[num].next;  
  165.         }  
  166.         Static_List->node[index].next = Static_List->node[num].next;  
  167.         Static_List->node[num].next = index;  
  168.           
  169.         Static_List->node[0].data++;  
  170.         Static_List->head = Static_List->node[0];//更新链表头节点   
  171.     }  
  172.     return ret;   
  173. }   
  174.   
  175.   
  176. /************************************************************************************************************** 
  177. 函数名： Get_StaticListNode 
  178. 函数功能：获得pos位置处的数据  pos的规则跟单向链表一样 
  179.           范围是 0  到   head->data  0是头节点 
  180. 参数：  SList* List 要插入的链表地址     int pos插入的位置  
  181. 返回值： 成功返回pos位置处的数据  失败返回NULL  
  182. **************************************************************************************************************/  
  183. SListNode* Get_StaticListNode(SList* List, int pos)  
  184. {  
  185.     SListNode* ret = NULL;  
  186.     int i = 0;  
  187.     int num = 0;  
  188.     StaticList* Static_List = (StaticList*)List;   
  189.     if( (NULL != Static_List) && (pos <= Static_List->head.data) && (pos >= 0) )  
  190.     {  
  191.         Static_List->node[0] = Static_List->head;   
  192.         for(i=0; i<pos; i++)  
  193.         {  
  194.             num = Static_List->node[num].next;  
  195.         }  
  196.         ret = (SListNode*)Static_List->node[num].data;   
  197.     }  
  198.     return ret;  
  199. }   
  200.   
  201.   
  202. /************************************************************************************************************** 
  203. 函数名： Del_StaticListNode 
  204. 函数功能：删除pos位置处的数据  pos的规则跟单向链表一样 
  205.           范围是 1  到   head->data  0是头节点 不能删除 
  206. 参数： SList* List 要插入的链表地址     int pos删除的位置 
  207. 返回值：成功返回 pos位置的数据 (目的在于：因为此数据一般是数据的地址  便于释放内存)    失败返回NULL  
  208. **************************************************************************************************************/  
  209. SListNode* Del_StaticListNode(SList* List, int pos)  
  210. {  
  211.     SListNode* ret = NULL;  
  212.     int i = 0;  
  213.     int num = 0;  
  214.     int temp = 0;   
  215.     StaticList* Static_List = (StaticList*)List;   
  216.     if( (NULL != Static_List) && (pos <= Static_List->head.data) && (pos > 0) )  
  217.     {  
  218.         Static_List->node[0] = Static_List->head;   
  219.         for(i=1; i<pos; i++)//得找到要删除的那个节点的上一个   
  220.         {  
  221.             num = Static_List->node[num].next;  
  222.         }  
  223.         temp = Static_List->node[num].next;  
  224.         Static_List->node[num].next = Static_List->node[temp].next;  
  225.           
  226.         Static_List->node[0].data--;  
  227.         Static_List->head = Static_List->node[0]; //更新链表头节点   
  228.           
  229.         Static_List->node[temp].next = AVAILABLE; //把删除的节点标志为可用节点   
  230.           
  231.         ret = (SListNode*)Static_List->node[temp].data;    
  232.     }  
  233.     return ret;  
  234.       
  235. }  


StaticList.h：
[cpp] view plaincopy
  1. #ifndef __STATICLIST_H__  
  2. #define __STATICLIST_H__   
  3.   
  4. typedef void SList;  
  5. typedef void SListNode;  
  6.   
  7. SList* Creat_StaticList(int capacity);  
  8. void Destroy_StaticList(SList* Static_List);  
  9. int Get_Lenth(SList* List);  
  10. int Get_Capacity(SList* List);  
  11. int Clear_StaticList(SList* List);  
  12. int Add_StaticList(SList* List, SListNode* Node, int pos);  
  13. SListNode* Get_StaticListNode(SList* List, int pos);  
  14. SListNode* Del_StaticListNode(SList* List, int pos);  
  15.   
  16. #endif  

main.c：
[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #include <string.h>  
  4. #include "StaticList.h"  
  5.   
  6. int main()  
  7. {  
  8.     SList* list = Creat_StaticList(10);  
  9.     int *f = 0;  
  10.     int i = 0;  
  11.     int a = 1;  
  12.     int b = 2;  
  13.     int c = 3;  
  14.     int d = 4;  
  15.     int e = 5;  
  16.       
  17.     Add_StaticList(list, &a, 0);  
  18.     Add_StaticList(list, &b, 0);  
  19.     Add_StaticList(list, &c, 0);  
  20.     Add_StaticList(list, &d, 0);  
  21.       
  22.     for(i=1; i<=Get_Lenth(list); i++)  
  23.     {  
  24.         f=(int* )Get_StaticListNode(list, i);  
  25.         printf("%d\n",*f);  
  26.     }  
  27.        
  28.     Add_StaticList(list, &e, 2);  
  29.     printf("\n");  
  30.     for(i=1; i<=Get_Lenth(list); i++)  
  31.     {  
  32.         f=(int* )Get_StaticListNode(list, i);  
  33.         printf("%d\n",*f);  
  34.     }   
  35.       
  36.     printf("\n");  
  37.     f=(int* )Del_StaticListNode(list, 4);  
  38.     printf("del %d\n",*f);  
  39.     printf("\n");  
  40.     for(i=1; i<=Get_Lenth(list); i++)  
  41.     {  
  42.         f=(int* )Get_StaticListNode(list, i);  
  43.         printf("%d\n",*f);  
  44.     }   
  45.     Destroy_StaticList(list);  
  46.     return 0;  
  47. }  

本节知识点：

1.为什么选择循环链表：因为有很多生活中结构是循环的，是单链表解决不了的，比如星期、月份、24小时，对于这些循环的数据，循环链表就体现出它的优势了。

2.循环链表的结构：

循环链表就是从头结点后面开始，尾节点的next不再是NULL了，而是头结点后面的第一个链表元素，如上图。

3.如何创建一个循环链表：

步骤一：

步骤二：

无论是头插法，还是尾插法都没有关系，都可以创建完成这个循环链表。

4.如何将一个单向链表改写成一个循环链表：

   第一步 (改写插入函数)：

   a.把插入位置pos的允许范围改成0~~~无穷大

[cpp] view plaincopy
  1. ret=( NULL != node) && ( NULL != Node) && (pos >= 0);  

   b.把两种方式的头插法情况加入程序，第一种是pos值为0和1的情况，如图：

   

   这种情况分为两部：先把node插入到head和第一个元素直接，然后再把链表尾指向node元素(node表示插入元素)。

   代码如下：

[cpp] view plaincopy
  1. if(node == (CircleListNode* )head)   
  2. {  
  3.     Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length); //获得链表最后一个元素   
  4.     Last->next = Node; //把头插法的数据连接到 链表的最后一个元素的后面   
  5. }  

   头插法的第二种情况，是循环链表，循环了一圈回来了，与第一种不同的是此时插入的相对位置和第一种的相对位置不一样。(其实这种方法跟普通插入是一样的)  如图：

   第二步  (改写删除函数)：

   a.也是把pos值的取值范围改成0  到 无穷大，但是同时记得判断length要大于0 ，要保证链表中有数据，不然删什么呀~~~~

[cpp] view plaincopy
  1. if(( NULL != lhead) && (pos > 0) && (lhead->length>0))  

   b.对于删除第一个元素有两种情况 这里是难点：首先要在删除链表元素的 前面 判断是否要删除第一个元素(此时的情况是pos为1的情况)，然后删除链表元素，再判断是否是删除第一个元素的第二种情况(链表循环一圈后，到达链表第一个元素，此时元素的前一个链表不再是head头结点了)。如图：


 代码如下：

[cpp] view plaincopy
  1. if(node == (CircleListNode* )head)  
  2. {  
  3.     Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length);  
  4. }  
  5.           
  6. ret = node->next;  
  7. node->next = ret->next;     
  8. /*判断是不是循环了一圈后回来的情况 */  
  9. if((first == ret) &&(NULL == Last))  
  10. {  
  11.     Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length);  
  12. }  
  13. /*判断是否要删除链表中的第一个元素*/  
  14. if( Last != NULL )  
  15. {  
  16.     Last->next = ret->next;   
  17.     lhead->head.next = ret->next;  
  18. }  

图中红笔的代码是：

[cpp] view plaincopy
  1. ret = node->next;  
  2. node->next = ret->next;     

图中蓝笔的代码是：

[cpp] view plaincopy
  1. if( Last != NULL )  
  2. {  
  3.     Last->next = ret->next;   
  4.     lhead->head.next = ret->next;  
  5. }  

   c.当length为0的是，即链表长度为0的时候，记得给头结点的next赋值为NULL

  第三步 (改写获得链表元素函数)

  a.记得把pos给成 0 到 无穷大，然后判断length链表长度是否为0 ，如果为0 就不能获取。

5.游标的引入：

在循环链表中一般可以定义一个游标，对于这样一个封装好的可复用循环链表，定义一个游标是十分方便的。例如：如果想依次获得链表中的每一个元素，利用get函数，太过低效了O(n2)，想想利用这样一个游标去遍历的话，复杂度仅仅是O(n)。还有就是在循环链表中，游标可以在链表中进行转圈，例如：可以解决约瑟夫环问题。


6.指定删除链表中某一个元素的函数CircleListNode* CircleList_Del(CircleList* head,CircleListNode* node)，其实也不是很高效，获得了当前游标的值的时候，再去调用CircleList_Del函数，这个轮询函数获得了pos，再去调用Del_CircleListNode然后又遍历了一边，把复杂的搞到了O(n2)。其实完全可以在找到pos的时候直接删除掉这个链表元素，这样的复杂度是O(n)。

7.我还觉得获得当前游标得值的函数CircleList_Slider的返回值有些问题，我觉得如果返回的是当前游标的上一个链表元素的值会更好，因为这个是一个单向链表，如果得到了上一个链表元素的值，就可以通过游标实现，删除啊，插入啊等高效的操作了。

本节代码：

CricleList.c：

[cpp] view plaincopy
  1. /******************************************************************************************************* 
  2. 文件名：CircleList.c 
  3. 头文件：CircleList.h  
  4. 时间： 2013/08/17 
  5. 作者： Hao 
  6. 功能:  可以复用 带有增 删 改 查 功能的循环链表 
  7. 难道： 1.typedef struct Str_CircleList CircleListNode;  //这个结构体是链表的真身  
  8.         struct Str_CircleList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型  
  9.         {                     //转换成(CircleListNode* )的时候  其实就是要开始对每个元素中的 CircleListNode进行赋值了  
  10.             CircleListNode* next; 
  11.         };  
  12.         这个链表结构在链表元素中起到的作用 是本节的难点  
  13.         2.切记一个问题  就是已经是链表中元素的 千万不要再往链表中添加了 否则链表一定出现无穷的错误  
  14.         3.对于pos值的问题  add、get、del三个函数中 的链表都是 从1开始的到length  0是链表头  
  15.                           在add函数中pos为0的时候是和pos为1的情况是一样的  都是头插法  0~~~~~无穷大  
  16.                           在get函数中pos为0的时候是获得链表头 地址      0~~~~~length  
  17.                           在del函数中pos为0的时候是无效的 del失败       1~~~~~length  
  18. *******************************************************************************************************/  
  19. #include <stdio.h>  
  20. #include <stdlib.h>  
  21. #include <malloc.h>  
  22. #include "CircleList.h"  
  23.   
  24. typedef struct str_list_head  //这个是链表头 其实也可以当作一个没有前驱的 链表元素 元素的内容是链表长度   
  25. {  
  26.     //CircleListNode* next;  
  27.     CircleListNode head; //这个参数要特别重视 每一个链表元素结构的第一个参数一定是 CircleListNode  
  28.                        //因为在寻找链表元素后继的时候 其实就是将链表元素强制类型转换成 CircleListNode*  然后给next进行赋值 其实就是给 CircleListNode变量赋值   
  29.     CircleListNode* slider;   
  30.     int length; //链表长度   
  31. }list_head;  
  32.   
  33. /******************************************************************************************************* 
  34. 函数名： Creat_CircleListHead 
  35. 函数功能：创建一个链表的链表头 并给链表头分配空间 
  36. 参数： void 
  37. 返回值：ret 成功返回链表头地址  失败返回NULL  
  38. *******************************************************************************************************/  
  39. CircleList* Creat_CircleListHead(void)  
  40. {  
  41.     list_head* ret = NULL;  
  42.     ret = (list_head* )malloc( sizeof(list_head)*1 );  
  43.     if(NULL != ret) //malloc分配成功   
  44.     {  
  45.         ret->length = 0;  
  46.         //ret -> next = NULL;  
  47.         ret->head.next = NULL;  
  48.         ret->slider = NULL;  
  49.     }  
  50.     return (CircleList* )ret;   
  51. }  
  52.   
  53. /******************************************************************************************************* 
  54. 函数名：Destroy_CircleListHead 
  55. 函数功能：释放一个链表头指针  
  56. 参数：CircleList* head 链表头指针  
  57. 返回值： ret 释放成功返回1  释放失败返回0  
  58. *******************************************************************************************************/  
  59. int Destroy_CircleListHead(CircleList* head)  
  60. {  
  61.     int ret = 0;   
  62.     list_head* lhead = (list_head* )head;  
  63.     if( NULL != lhead )  
  64.     {  
  65.         free(lhead);  
  66.         ret = 1;  
  67.     }  
  68.     return ret;  
  69. }  
  70.   
  71. /******************************************************************************************************* 
  72. 函数名:Get_Length 
  73. 函数功能：获得链表的长度  
  74. 参数: CircleList* head 链表头指针  
  75. 返回值： ret 成功返回链表长度  失败返回0  
  76. *******************************************************************************************************/  
  77. int Get_Length(CircleList* head)   
  78. {  
  79.     int ret = 0;  
  80.     list_head* lhead = (list_head* )head;  
  81.     if( NULL != lhead )  
  82.     {  
  83.         ret = lhead -> length;  
  84.     }     
  85.     return ret;  
  86. }  
  87.   
  88. /******************************************************************************************************* 
  89. 函数名：Clean_CircleListHead 
  90. 函数功能：   清空链表  
  91. 参数： CircleList* head 链表头指针  
  92. 返回值：ret 成功返回1 失败返回0  
  93. *******************************************************************************************************/  
  94. int Clean_CircleListHead(CircleList* head)   
  95. {  
  96.     int ret = 0;  
  97.     list_head* lhead = (list_head* )head;  
  98.     if( NULL != lhead )  
  99.     {  
  100.         lhead -> length = 0;  
  101.         //lhead  -> next = NULL;  
  102.         lhead -> head.next = NULL;  
  103.         lhead->slider = NULL;  
  104.         ret = 1;  
  105.     }     
  106.     return ret;  
  107. }  
  108.   
  109. /******************************************************************************************************* 
  110. 函数名:Add_CircleList 
  111. 函数功能：往链表里面添加一个链表元素 如果pos的值是0(就是链表头)和1(链表的第一元素 链表元素个数是从1开始算的)都是头插法 
  112.           pos的值大于链表长度是尾插法  这里面pos值得注意的是 i=1 pos为a的时候 是把链表元素插入第a个元素的位置  
  113.           当i=0 pos为a的时候 是把链表元素插入 第a个元素位置的后面    切忌：这里面0位置是链表头指针 从1开始是链表元素  
  114. 参数：   CircleList* head链表头指针    CircleListNode* Node插入元素的指针(被强制类型转化成CircleListNode*)  int pos 插入位置  
  115.          pos的有效值范围是 从0到无穷大   
  116. 返回值： ret 插入成功返回1  插入失败返回0  
  117. *******************************************************************************************************/  
  118. int Add_CircleList(CircleList* head, CircleListNode* Node, int pos)  
  119. {  
  120.     int ret = 0;  
  121.     int i = 0;  
  122.     list_head* lhead = (list_head* )head;  
  123.     CircleListNode* node = (CircleListNode* )head;  
  124.     CircleListNode* Last = NULL;  
  125.     ret=( NULL != node) && ( NULL != Node) && (pos >= 0);  
  126.     if(1 == ret)  
  127.     {  
  128.         for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  129.         {  
  130.             node = node->next;  
  131.         }  
  132.         Node -> next = node -> next;  
  133.         node -> next = Node;  
  134.         if(lhead->length == 0)//第一次插入元素的时候把游标 指向这个元素    
  135.         {  
  136.             lhead->slider = Node;  
  137.         }  
  138.         lhead -> length++; //这个一定要在后面调用 lhead->length值的前面更新   
  139.         /*判断是否为头插法  所谓头插法 就是pos为0和1的情况 其实也就是没有进for循环的情况  剩下的无论pos为多少  进入多少次循环都没有头插法*/  
  140.         if(node == (CircleListNode* )head)   
  141.         {  
  142.             Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length); //获得链表最后一个元素   
  143.             Last->next = Node; //把头插法的数据连接到 链表的最后一个元素的后面   
  144.         }  
  145.           
  146.     }  
  147.     return ret;  
  148. }  
  149.   
  150. /******************************************************************************************************* 
  151. 函数名：Get_CircleListNode 
  152. 函数功能：获得链表中第pos个元素位置的链表元素 链表是从1开始的  0是链表头   pos为0的时候表示get链表头  
  153. 参数： CircleList* head链表头指针    int pos获得链表元素的位置  pos的有效取值范围是 1 到  length  0是链表头  
  154. 返回值： CircleListNode*类型 第pos个链表元素的地址  
  155. *******************************************************************************************************/  
  156. CircleListNode* Get_CircleListNode(CircleList* head, int pos)  
  157. {  
  158.     int ret = 0;  
  159.     int i = 0;  
  160.     list_head* lhead = (list_head* )head;  
  161.     /*本来pos应该是有上限的  但是变成了循环链表pos理论上说就可以无穷大了  但是get函数应该是在链表中有值的情况下才成立的 即(lhead->length>0)*/   
  162.     ret=( NULL != lhead) && (pos >= 0) && (lhead->length>0);   
  163.     if(1 == ret)  
  164.     {  
  165.         CircleListNode* node = (CircleListNode* )head;  
  166.         for(i=0; i<pos; i++) //执行 pos次   得到的是第pos位置的node   
  167.         {  
  168.             node = node->next;  
  169.         }     
  170.         return (CircleListNode*)node;  
  171.     }  
  172.     return NULL;  
  173. }  
  174.   
  175. /******************************************************************************************************* 
  176. 函数名：Del_CircleListNode 
  177. 函数功能：删除链表中第pos位置的链表元素  
  178. 参数： CircleList* head链表头指针    int pos删除链表元素的位置  pos是删除的链表元素的位置 跟get和add中的 
  179.        pos是配套的  有效取值范围依然是 1到 length  在这个函数里面由于不能删除链表头 所以pos为0的时候无效  
  180. 返回值： CircleListNode* ret这个返回值很重要 因为这个删除仅仅是把链表元素踢出了链表 并没有free开辟的内存 
  181.          应该通过这个返回的地址free  释放内存 
  182.          删除成功返回 删除链表元素的地址   删除失败返回 NULL  
  183. *******************************************************************************************************/  
  184. CircleListNode* Del_CircleListNode(CircleList* head, int pos)  
  185. {  
  186.     CircleListNode* ret = NULL;  
  187.     CircleListNode* Last = NULL;  
  188.     int i = 0;  
  189.     list_head* lhead = (list_head* )head;  
  190.     CircleListNode* first = lhead->head.next;  
  191.       
  192.     if(( NULL != lhead) && (pos > 0) && (lhead->length>0))  
  193.     {  
  194.         CircleListNode* node = (CircleListNode* )head;  
  195.         for(i=1; i<pos; i++)//执行 pos次   得到的是第pos位置的node  这个方法行不通   
  196.         {                   //因为要想删除第pos位置的node 应该先找到它上一个链表元素   
  197.             node = node->next; //所以这里面i=1 比get函数少执行了一次  得到第pos-1位置的node   
  198.         }  
  199.         /*判断是不是 pos为1的 情况删除头节点后面的第一个元素(这个是没有进入for循环的)  跟循环一圈后的情况不一样  */  
  200.         /*循环一圈的是进入for循环的情况   此时的node不再是head了 而是链表最后一个元素*/   
  201.         if(node == (CircleListNode* )head)  
  202.         {  
  203.             Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length);  
  204.         }  
  205.           
  206.         ret = node->next;  
  207.         node->next = ret->next;     
  208.         /*判断是不是循环了一圈后回来的情况 */  
  209.         if((first == ret) &&(NULL == Last))  
  210.         {  
  211.             Last =(CircleListNode* )Get_CircleListNode(lhead, lhead->length);  
  212.         }  
  213.         /*判断是否要删除链表中的第一个元素*/  
  214.         if( Last != NULL )  
  215.         {  
  216.             Last->next = ret->next;   
  217.             lhead->head.next = ret->next;  
  218.         }  
  219.         if( lhead->slider == ret)//如果删除的元素恰恰就是游标指向的元素  要把游标往后面移动一位   
  220.         {  
  221.             lhead->slider = ret->next;  
  222.         }  
  223.         lhead->length--; //这个一定要写在 Get_CircleListNode 后面 不然的话 pos就为0了   
  224.         /*判断链表是否 减到了空  如果链表中不再有元素 就把head.next赋值为NULL*/  
  225.         /*单向链表不需要这个的原因 是因为单向链表的最后一个元素的next就是NULL 而双向链表没有NULL的了*/  
  226.         if(0 == lhead->length)  
  227.         {  
  228.             lhead->head.next = NULL;  
  229.             lhead->slider = NULL;   
  230.         }  
  231.           
  232.     }  
  233.     return (CircleListNode*)ret;  
  234. }  
  235.   
  236. /******************************************************************************************************* 
  237. 函数名： CircleList_Slider 
  238. 函数功能：获得当前游标指向的数据 
  239. 参数： CircleList* head 
  240. 返回值：成功返回 CircleListNode* ret  失败返回NULL  
  241. *******************************************************************************************************/  
  242. CircleListNode* CircleList_Slider(CircleList* head)  
  243. {  
  244.     CircleListNode* ret = NULL;  
  245.     list_head* lhead = (list_head* )head;  
  246.     if( (NULL != lhead)&&(NULL != lhead->slider) )//保证slider是有效的   
  247.     {  
  248.         ret = lhead->slider;  
  249.     }  
  250.     return ret;  
  251. }  
  252.   
  253. /******************************************************************************************************* 
  254. 函数名： CircleList_Reset 
  255. 函数功能：重置游标 让游标指向head头节点后面的第一个元素  
  256. 参数： CircleList* head 
  257. 返回值：成功返回 当前游标的指向CircleListNode* ret  失败返回NULL  
  258. *******************************************************************************************************/  
  259. CircleListNode* CircleList_Reset(CircleList* head)  
  260. {  
  261.     CircleListNode* ret = NULL;  
  262.     list_head* lhead = (list_head* )head;  
  263.     if(NULL != lhead)  
  264.     {  
  265.         lhead->slider = lhead->head.next;  
  266.         ret = lhead->slider;  
  267.     }  
  268.     return ret;  
  269. }  
  270.   
  271. /******************************************************************************************************* 
  272. 函数名： CircleList_Next 
  273. 函数功能：使游标指向下一个元素  
  274. 参数： CircleList* head 
  275. 返回值：成功返回 前游标的指向CircleListNode* ret  失败返回NULL  
  276. *******************************************************************************************************/  
  277. CircleListNode* CircleList_Next(CircleList* head)  
  278. {  
  279.     CircleListNode* ret = NULL;  
  280.     list_head* lhead = (list_head* )head;  
  281.     if((NULL != lhead)&&(NULL != lhead->slider)) //保证游标是有效的   
  282.     {  
  283.         ret = lhead->slider;  
  284.         lhead->slider = ret->next;   
  285.     }  
  286.     return ret;  
  287. }  
  288.   
  289. /******************************************************************************************************* 
  290. 函数名： CircleList_Del 
  291. 函数功能：删除链表中的某个指定元素  
  292. 参数： CircleList* head   CircleListNode* node为指定的元素  
  293. 返回值：成功返回 删除的链表元素  失败返回NULL  
  294. *******************************************************************************************************/  
  295. CircleListNode* CircleList_Del(CircleList* head,CircleListNode* node)  
  296. {   //这个函数主要是用来删除游标的返回值的   
  297.    
  298.     CircleListNode* ret = NULL;  
  299.     list_head* lhead = (list_head* )head;  
  300.     int i=0;   
  301.     if((NULL != head)&&(NULL != node))  
  302.     {  
  303.         CircleListNode* current = (CircleListNode*)lhead;  
  304.         for(i=1; i<=lhead->length; i++)  
  305.         {  
  306.             if(node == current->next)  
  307.             {  
  308.                 ret = current->next;  
  309.                 break;   
  310.             }   
  311.             current = current->next;  
  312.         }  
  313.           
  314.         if(NULL == ret)  //说明没有找到node   
  315.         {  
  316.             printf("put error!!!\n");   
  317.         }  
  318.         else //找到了node   
  319.         {  
  320.             Del_CircleListNode(lhead,i);   
  321.         }   
  322.     }     
  323.     return ret;//返回删除的链表元素   
  324. }  


CircleList.h：

[cpp] view plaincopy
  1. #ifndef __CircleList_H__  
  2. #define __CircleList_H__  
  3.   
  4. typedef void CircleList;  //这个是为了 封装方便   
  5. typedef struct Str_CircleList CircleListNode;  //这个结构体是链表的真身   
  6. struct Str_CircleList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  7. {                     //转换成(CircleListNode* )的时候  其实就是要开始对每个元素中的 CircleListNode进行赋值了   
  8.     CircleListNode* next;  
  9. };  
  10.   
  11. CircleList* Creat_CircleListHead(void);  
  12.   
  13. int Destroy_CircleListHead(CircleList* head);  
  14.   
  15. int Get_Length(CircleList* head);  
  16.   
  17. int Clean_CircleListHead(CircleList* head);  
  18.   
  19. int Add_CircleList(CircleList* head, CircleListNode* Node, int pos);  
  20.   
  21. CircleListNode* Get_CircleListNode(CircleList* head, int pos);  
  22.   
  23. CircleListNode* Del_CircleListNode(CircleList* head, int pos);   
  24.   
  25. CircleListNode* CircleList_Del(CircleList* head,CircleListNode* node);  
  26.   
  27. CircleListNode* CircleList_Next(CircleList* head);  
  28.   
  29. CircleListNode* CircleList_Reset(CircleList* head);  
  30.   
  31. CircleListNode* CircleList_Slider(CircleList* head);  
  32.    
  33. #endif  


main.c：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "CircleList.h"  
  4.   
  5. typedef struct _tag_str  
  6. {  
  7.     CircleListNode head;  
  8.     int i;  
  9. }str;  
  10. int main(int argc, char *argv[])   
  11. {  
  12.     str str1,str2,str3,str4,str5,str6;  
  13.     str *strp;  
  14.     int i=0;  
  15.     str1.i=1;  
  16.     str2.i=2;  
  17.     str3.i=3;  
  18.     str4.i=4;  
  19.     str5.i=5;  
  20.     str6.i=6;  
  21.     CircleList* head;  
  22.     head = Creat_CircleListHead();  
  23.       
  24.     Add_CircleList(head, (CircleListNode*)&str1, 0);  
  25.     Add_CircleList(head, (CircleListNode*)&str2, 0);  
  26.     Add_CircleList(head, (CircleListNode*)&str3, 0);  
  27.     Add_CircleList(head, (CircleListNode*)&str4, 0);  
  28.     Add_CircleList(head, (CircleListNode*)&str5, 5);  
  29.       
  30.     for(i=1; i<=2*Get_Length(head); i++)  
  31.     {  
  32.         strp = (str* )Get_CircleListNode(head, i);  
  33.         printf("%d\n",strp->i);  
  34.     }  
  35.     printf("\n");  
  36.       
  37.     printf("%d\n",Get_Length(head));  
  38.     strp = (str* )Del_CircleListNode(head, 6);  
  39.     printf("%d\n",strp->i);    
  40.       
  41.     printf("%d\n",Get_Length(head));  
  42.     printf("\n");  
  43.     for(i=1; i<=2*Get_Length(head); i++)  
  44.     {  
  45.         strp = (str* )Get_CircleListNode(head, i);  
  46.         printf("%d\n",strp->i);  
  47.     }  
  48.       
  49.     printf("\n");  
  50.     printf("%d\n",Get_Length(head));  
  51.     strp = (str* )Del_CircleListNode(head, 1);  
  52.     printf("%d\n",strp->i);    
  53.       
  54.     printf("%d\n",Get_Length(head));  
  55.     printf("\n");  
  56.     for(i=1; i<=2*Get_Length(head); i++)  
  57.     {  
  58.         strp = (str* )Get_CircleListNode(head, i);  
  59.         printf("%d\n",strp->i);  
  60.     }  
  61.       
  62.       
  63.       
  64.       
  65.     printf("\n");  
  66.     for(i=1; i<=3; i++)  
  67.     {  
  68.         strp = (str* )Del_CircleListNode(head, 1);  
  69.         printf("%d\n",strp->i);  
  70.     }  
  71.       
  72.     /*CircleList_Reset(head); 
  73.     CircleList_Next(head); 
  74.     CircleList_Del(head,(CircleListNode*)&str3); 
  75.     strp = (str* )CircleList_Slider(head); 
  76.     printf("%d\n",strp->i); 
  77.     printf("\n"); 
  78.      
  79.     for(i=1; i<=2*Get_Length(head); i++) 
  80.     { 
  81.         strp = (str* )Get_CircleListNode(head, i); 
  82.         printf("%d\n",strp->i); 
  83.     } 
  84.     printf("\n");*/  
  85.       
  86.   
  87.       
  88.     Destroy_CircleListHead(head);  
  89.     return 0;  
  90. }  



 

 

 

 

本节知识点：

1.为什么选择双向链表：因为单向链表只能一直指向下一个链表元素，不能获得前一个元素，如果要进行逆序访问操作是极其耗时的，所以引入双向链表。
2.双向链表的结构：在单向链表的基础上增加了一个链表结构pre，如图。
注意：链表第一个元素的前驱pre不是指向头结点head，而是指向NULL，链表尾结点的后继next指向NULL
3.如何将一个单向链表改成双向链表：
   第一步 (改变链表的结构加入前驱)：
[cpp] view plaincopy
  1. struct Str_DLinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  2. {                     //转换成(DLinkListNode* )的时候  其实就是要开始对每个元素中的 DLinkListNode进行赋值了   
  3.     DLinkListNode* next;  
  4.     DLinkListNode* pre;  
  5. };  

   第二步 (改写插入函数)：
   对于一个尾插法，如图：
   
    (1).正常的链表插入操作，代码如下：
[cpp] view plaincopy
  1. for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  2. {  
  3.     node = node->next;  
  4. }  
  5. /*此处的node是要插入元素的前一个值  Node是要删除的值*/   
  6. Node -> next = node -> next;  
  7. node -> next = Node;  
    (2).把刚刚插入的数据的前驱pre跟前一个数据元素相连，代码如下：
[cpp] view plaincopy
  1. Node->pre = node;  
    对于一个正常插入，如图：

    (1).正常的链表插入操作，代码如下：
[cpp] view plaincopy
  1. for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  2. {  
  3.     node = node->next;  
  4. }  
  5. /*此处的node是要插入元素的前一个值  Node是要删除的值*/   
  6. Node -> next = node -> next;  
  7. node -> next = Node;  
    (2).先判断是不是尾插法，如果是尾插法，就像上一个情况一样，就不进行这一步的操作了，代码如下：
[cpp] view plaincopy
  1. if(NULL != Node->next) //判断是否为尾插法 如果不是进入如下操作   如果是尾插法  最后一个链表元素不当作NULL的前驱   
  2. {  
  3.     Node->next->pre = Node;   
  4. }  
   (3).把刚刚插入的数据的前驱pre跟前一个数据元素相连，代码如下：
[cpp] view plaincopy
  1. Node->pre = node;  
   对于一个头插法，如图：



     (1).正常的链表插入操作，代码如下：
[cpp] view plaincopy
  1. for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  2. {  
  3.     node = node->next;  
  4. }  
  5. /*此处的node是要插入元素的前一个值  Node是要删除的值*/   
  6. Node -> next = node -> next;  
  7. node -> next = Node;  
     (2).把附近的两个链表的前驱pre都赋值为正确的值，代码如下：
[cpp] view plaincopy
  1. if(NULL != Node->next) //判断是否为尾插法 如果不是进入如下操作   如果是尾插法  最后一个链表元素不当作NULL的前驱   
  2. {  
  3.     Node->next->pre = Node;   
  4. }  
  5. Node->pre = node;  
     (3).如果是头插法，要记得把插入的元素结点的前驱pre赋值为NULL，代码如下：
[cpp] view plaincopy
  1. if( node == (DLinkListNode* )head)  //如果是头插法 就要将第一个链表元素的前驱写成NULL  不然前驱就变成了头节点了   
  2. {  
  3.     Node->pre = NULL;  
  4. }  
    (4).第一次插入链表元素，要把游标指向插入的链表元素，代码如下：
[cpp] view plaincopy
  1. if( 0==lhead->length ) //在第一次插入元素的时候  把游标指向第一次个元素   
  2. {  
  3.     lhead->slider = Node;  
  4. }  
     第三步 (改写删除函数)：
     有三种情况分别是：删除的是第一个结点元素，删除的是最后一个结点元素，删除的是中间结点元素。
     (1).删除第一个结点元素：要注意给下一个结点元素的前驱pre赋值为NULL，不是指向head
     (2).删除最后一个结点元素：要注意不要给next的前驱再赋值了，因为next已经为NULL了。并且此时要把游标往再往前面移动一个位置。代码如下：
[cpp] view plaincopy
  1. DLinkListNode* Del_DLinkListNode(DLinkList* head, int pos)  
  2. {  
  3.     DLinkListNode* ret = NULL;  
  4.     int i = 0;  
  5.     list_head* lhead = (list_head* )head;  
  6.     if(( NULL != lhead) && (pos > 0) && (pos <= lhead->length))  
  7.     {  
  8.         DLinkListNode* node = (DLinkListNode* )head;  
  9.         for(i=1; i<pos; i++)//执行 pos次   得到的是第pos位置的node  这个方法行不通   
  10.         {                   //因为要想删除第pos位置的node 应该先找到它上一个链表元素   
  11.             node = node->next; //所以这里面i=1 比get函数少执行了一次  得到第pos-1位置的node   
  12.         }  
  13.         /*值得注意的是 此处的node是要删除元素的前一个值  ret是要删除的值*/  
  14.         ret = node->next;  
  15.         node->next = ret->next;     
  16.   
  17.         if(NULL != ret->next) //判断删除的值是否为最后一个元素   
  18.         {  
  19.             ret->next->pre = ret->pre;  
  20.             if(node == (DLinkListNode* )head)//判断删除的值是否为第一个元素   
  21.             {  
  22.                 ret->next->pre =  NULL;  
  23.             }   
  24.             if(lhead->slider == ret) //判断删除的节点是否为游标的位置   
  25.             {  
  26.                   
  27.                 lhead->slider = ret->next;   
  28.             }   
  29.         }   
  30.         else  
  31.         {  
  32.             if(lhead->slider == ret) //判断删除的节点是否为游标的位置   
  33.             {  
  34.                   
  35.                 lhead->slider = ret->pre;   
  36.             }  
  37.         }  
  38.   
  39.         lhead->length--;  
  40.     }  
  41.     return (DLinkListNode*)ret;  
  42. }  

4.双向链表的快速排序：
对于双向链表进行快速排序的效率还不错，比用冒泡排序好很多~~~~~~~此时对快速排序还不是很理解~~~~~等到有了一定理解再回来想想吧！！！
想要提示的一点是，快排是依赖递归实现的，对于递归是有递归层次限制的(其实也是栈溢出的问题)，所以快排的最坏情况是已经排序好了的情况，所以对一个链表重复进行快排很容易出现栈溢出的问题！！！


本节代码：

DLinkList.c：

[cpp] view plaincopy
  1. /******************************************************************************************************* 
  2. 文件名：DLinkList.c 
  3. 头文件：DLinkList.h  
  4. 时间： 2013/08/17 
  5. 作者： Hao 
  6. 功能:  可以复用 带有增 删 改 查 功能的循环链表 
  7. 难道： 1.typedef struct Str_DLinkList DLinkListNode;  //这个结构体是链表的真身  
  8.         struct Str_DLinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型  
  9.         {                     //转换成(DLinkListNode* )的时候  其实就是要开始对每个元素中的 DLinkListNode进行赋值了  
  10.             DLinkListNode* next; 
  11.         };  
  12.         这个链表结构在链表元素中起到的作用 是本节的难点  
  13.         2.切记一个问题  就是已经是链表中元素的 千万不要再往链表中添加了 否则链表一定出现无穷的错误  
  14.         3.对于pos值的问题  add、get、del三个函数中 的链表都是 从1开始的到length  0是链表头  
  15.                           在add函数中pos为0的时候是和pos为1的情况是一样的  都是头插法  0~~~~~无穷大  
  16.                           在get函数中pos为0的时候是获得链表头 地址      0~~~~~length  
  17.                           在del函数中pos为0的时候是无效的 del失败       1~~~~~length  
  18. *******************************************************************************************************/  
  19. #include <stdio.h>  
  20. #include <stdlib.h>  
  21. #include <malloc.h>  
  22. #include "DLinkList.h"  
  23.   
  24. typedef struct str_list_head  //这个是链表头 其实也可以当作一个没有前驱的 链表元素 元素的内容是链表长度   
  25. {  
  26.     //DLinkListNode* next;  
  27.     DLinkListNode head; //这个参数要特别重视 每一个链表元素结构的第一个参数一定是 DLinkListNode  
  28.                        //因为在寻找链表元素后继的时候 其实就是将链表元素强制类型转换成 DLinkListNode*  然后给next进行赋值 其实就是给 DLinkListNode变量赋值   
  29.     DLinkListNode* slider;  
  30.     int length; //链表长度   
  31. }list_head;  
  32.   
  33. /******************************************************************************************************* 
  34. 函数名： Creat_DLinkListHead 
  35. 函数功能：创建一个链表的链表头 并给链表头分配空间 
  36. 参数： void 
  37. 返回值：ret 成功返回链表头地址  失败返回NULL  
  38. *******************************************************************************************************/  
  39. DLinkList* Creat_DLinkListHead(void)  
  40. {  
  41.     list_head* ret = NULL;  
  42.     ret = (list_head* )malloc( sizeof(list_head)*1 );  
  43.     if(NULL != ret) //malloc分配成功   
  44.     {  
  45.         ret->length = 0;  
  46.         //ret -> next = NULL;  
  47.         ret->head.next = NULL;  
  48.         ret->head.pre = NULL;  
  49.         ret->slider = NULL;  
  50.     }  
  51.     return (DLinkList* )ret;   
  52. }  
  53.   
  54. /******************************************************************************************************* 
  55. 函数名：Destroy_DLinkListHead 
  56. 函数功能：释放一个链表头指针  
  57. 参数：DLinkList* head 链表头指针  
  58. 返回值： ret 释放成功返回1  释放失败返回0  
  59. *******************************************************************************************************/  
  60. int Destroy_DLinkListHead(DLinkList* head)  
  61. {  
  62.     int ret = 0;   
  63.     list_head* lhead = (list_head* )head;  
  64.     if( NULL != lhead )  
  65.     {  
  66.         free(lhead);  
  67.         ret = 1;  
  68.     }  
  69.     return ret;  
  70. }  
  71.   
  72. /******************************************************************************************************* 
  73. 函数名:Get_Length 
  74. 函数功能：获得链表的长度  
  75. 参数: DLinkList* head 链表头指针  
  76. 返回值： ret 成功返回链表长度  失败返回0  
  77. *******************************************************************************************************/  
  78. int Get_Length(DLinkList* head)   
  79. {  
  80.     int ret = 0;  
  81.     list_head* lhead = (list_head* )head;  
  82.     if( NULL != lhead )  
  83.     {  
  84.         ret = lhead -> length;  
  85.     }     
  86.     return ret;  
  87. }  
  88.   
  89. /******************************************************************************************************* 
  90. 函数名：Clean_DLinkListHead 
  91. 函数功能：   清空链表  
  92. 参数： DLinkList* head 链表头指针  
  93. 返回值：ret 成功返回1 失败返回0  
  94. *******************************************************************************************************/  
  95. int Clean_DLinkListHead(DLinkList* head)   
  96. {  
  97.     int ret = 0;  
  98.     list_head* lhead = (list_head* )head;  
  99.     if( NULL != lhead )  
  100.     {  
  101.         lhead->length = 0;  
  102.         //lhead -> next = NULL;  
  103.         lhead->head.next = NULL;  
  104.         lhead->head.pre = NULL;  
  105.         lhead->slider = NULL;  
  106.         ret = 1;  
  107.     }     
  108.     return ret;  
  109. }  
  110.   
  111. /******************************************************************************************************* 
  112. 函数名:Add_DLinkList 
  113. 函数功能：往链表里面添加一个链表元素 如果pos的值是0(就是链表头)和1(链表的第一元素 链表元素个数是从1开始算的)都是头插法 
  114.           pos的值大于链表长度是尾插法  这里面pos值得注意的是 i=1 pos为a的时候 是把链表元素插入第a个元素的位置  
  115.           当i=0 pos为a的时候 是把链表元素插入 第a个元素位置的后面    切忌：这里面0位置是链表头指针 从1开始是链表元素  
  116. 参数：   DLinkList* head链表头指针    DLinkListNode* Node插入元素的指针(被强制类型转化成DLinkListNode*)  int pos 插入位置  
  117.          pos的有效值范围是 从0到无穷大   
  118. 返回值： ret 插入成功返回1  插入失败返回0  
  119. *******************************************************************************************************/  
  120. int Add_DLinkList(DLinkList* head, DLinkListNode* Node, int pos)  
  121. {  
  122.     int ret = 0;  
  123.     int i = 0;  
  124.     list_head* lhead = (list_head* )head;  
  125.     DLinkListNode* node = (DLinkListNode* )head;  
  126.     ret=( NULL != node) && ( NULL != Node) && (pos >= 0);  
  127.     if(1 == ret)  
  128.     {  
  129.         for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  130.         {  
  131.             node = node->next;  
  132.         }  
  133.         /*此处的node是要插入元素的前一个值  Node是要删除的值*/   
  134.         Node -> next = node -> next;  
  135.         node -> next = Node;  
  136.         if(NULL != Node->next) //判断是否为尾插法 如果不是进入如下操作   如果是尾插法  最后一个链表元素不当作NULL的前驱   
  137.         {  
  138.             Node->next->pre = Node;   
  139.         }  
  140.         Node->pre = node;  
  141.           
  142.         if( 0==lhead->length ) //在第一次插入元素的时候  把游标指向第一次个元素   
  143.         {  
  144.             lhead->slider = Node;  
  145.         }  
  146.         if( node == (DLinkListNode* )head)  //如果是头插法 就要将第一个链表元素的前驱写成NULL  不然前驱就变成了头节点了   
  147.         {  
  148.             Node->pre = NULL;  
  149.         }  
  150.           
  151.         lhead -> length++;   
  152.     }  
  153.     return ret;  
  154. }  
  155.   
  156. /******************************************************************************************************* 
  157. 函数名：Get_DLinkListNode 
  158. 函数功能：获得链表中第pos个元素位置的链表元素 链表是从1开始的  0是链表头   pos为0的时候表示get链表头  
  159. 参数： DLinkList* head链表头指针    int pos获得链表元素的位置  pos的有效取值范围是 1 到  length  0是链表头  
  160. 返回值： DLinkListNode*类型 第pos个链表元素的地址  
  161. *******************************************************************************************************/  
  162. DLinkListNode* Get_DLinkListNode(DLinkList* head, int pos)  
  163. {  
  164.     int ret = 0;  
  165.     int i = 0;  
  166.     list_head* lhead = (list_head* )head;  
  167.     ret=( NULL != lhead) && (pos >= 0) && (pos <= lhead->length);  
  168.     if(1 == ret)  
  169.     {  
  170.         DLinkListNode* node = (DLinkListNode* )head;  
  171.         for(i=0; i<pos; i++) //执行 pos次   得到的是第pos位置的node   
  172.         {  
  173.             node = node->next;  
  174.         }     
  175.         return (DLinkListNode*)node;  
  176.     }  
  177.     return NULL;  
  178. }  
  179.   
  180. /******************************************************************************************************* 
  181. 函数名：Del_DLinkListNode 
  182. 函数功能：删除链表中第pos位置的链表元素  
  183. 参数： DLinkList* head链表头指针    int pos删除链表元素的位置  pos是删除的链表元素的位置 跟get和add中的 
  184.        pos是配套的  有效取值范围依然是 1到 length  在这个函数里面由于不能删除链表头 所以pos为0的时候无效  
  185. 返回值： DLinkListNode* ret这个返回值很重要 因为这个删除仅仅是把链表元素踢出了链表 并没有free开辟的内存 
  186.          应该通过这个返回的地址free  释放内存 
  187.          删除成功返回 删除链表元素的地址   删除失败返回 NULL  
  188. *******************************************************************************************************/  
  189. DLinkListNode* Del_DLinkListNode(DLinkList* head, int pos)  
  190. {  
  191.     DLinkListNode* ret = NULL;  
  192.     int i = 0;  
  193.     list_head* lhead = (list_head* )head;  
  194.     if(( NULL != lhead) && (pos > 0) && (pos <= lhead->length))  
  195.     {  
  196.         DLinkListNode* node = (DLinkListNode* )head;  
  197.         for(i=1; i<pos; i++)//执行 pos次   得到的是第pos位置的node  这个方法行不通   
  198.         {                   //因为要想删除第pos位置的node 应该先找到它上一个链表元素   
  199.             node = node->next; //所以这里面i=1 比get函数少执行了一次  得到第pos-1位置的node   
  200.         }  
  201.         /*值得注意的是 此处的node是要删除元素的前一个值  ret是要删除的值*/  
  202.         ret = node->next;  
  203.         node->next = ret->next;     
  204.   
  205.         if(NULL != ret->next) //判断删除的值是否为最后一个元素   
  206.         {  
  207.             ret->next->pre = ret->pre;  
  208.             if(node == (DLinkListNode* )head)//判断删除的值是否为第一个元素   
  209.             {  
  210.                 ret->next->pre =  NULL;  
  211.             }   
  212.             if(lhead->slider == ret) //判断删除的节点是否为游标的位置   
  213.             {  
  214.                   
  215.                 lhead->slider = ret->next;   
  216.             }   
  217.         }   
  218.         else  
  219.         {  
  220.             if(lhead->slider == ret) //判断删除的节点是否为游标的位置   
  221.             {  
  222.                   
  223.                 lhead->slider = ret->pre;   
  224.             }  
  225.         }  
  226.   
  227.         lhead->length--;  
  228.     }  
  229.     return (DLinkListNode*)ret;  
  230. }  
  231.   
  232. /******************************************************************************************************* 
  233. 函数名： DLinkList_Slider 
  234. 函数功能：获得当前游标指向的数据 
  235. 参数： DLinkList* head 
  236. 返回值：成功返回 DLinkListNode* ret  失败返回NULL  
  237. *******************************************************************************************************/  
  238. DLinkListNode* DLinkList_Slider(DLinkList* head)  
  239. {  
  240.     DLinkListNode* ret = NULL;  
  241.     list_head* lhead = (list_head* )head;  
  242.     if( (NULL != lhead)&&(NULL != lhead->slider) )//保证slider是有效的   
  243.     {  
  244.         ret = lhead->slider;  
  245.     }  
  246.     return ret;  
  247. }  
  248.   
  249. /******************************************************************************************************* 
  250. 函数名： DLinkList_Reset 
  251. 函数功能：重置游标 让游标指向head头节点后面的第一个元素  
  252. 参数： DLinkList* head 
  253. 返回值：成功返回 当前游标的指向DLinkListNode* ret  失败返回NULL  
  254. *******************************************************************************************************/  
  255. DLinkListNode* DLinkList_Reset(DLinkList* head)  
  256. {  
  257.     DLinkListNode* ret = NULL;  
  258.     list_head* lhead = (list_head* )head;  
  259.     if(NULL != lhead)  
  260.     {  
  261.         lhead->slider = lhead->head.next;  
  262.         ret = lhead->slider;  
  263.     }  
  264.     return ret;  
  265. }  
  266.   
  267. /******************************************************************************************************* 
  268. 函数名： DLinkList_Next 
  269. 函数功能：使游标指向下一个元素  
  270. 参数： DLinkList* head 
  271. 返回值：成功返回 前游标的指向DLinkListNode* ret  失败返回NULL  
  272. *******************************************************************************************************/  
  273. DLinkListNode* DLinkList_Next(DLinkList* head)  
  274. {  
  275.     DLinkListNode* ret = NULL;  
  276.     list_head* lhead = (list_head* )head;  
  277.     if((NULL != lhead)&&(NULL != lhead->slider)) //保证游标是有效的   
  278.     {  
  279.         ret = lhead->slider;  
  280.         lhead->slider = ret->next;   
  281.     }  
  282.     return ret;  
  283. }  
  284.   
  285. /******************************************************************************************************* 
  286. 函数名： DLinkList_Pre 
  287. 函数功能：使游标指向上一个元素  
  288. 参数： DLinkList* head 
  289. 返回值：成功返回 前游标的指向DLinkListNode* ret  失败返回NULL  
  290. *******************************************************************************************************/  
  291. DLinkListNode* DLinkList_Pre(DLinkList* head)  
  292. {  
  293.     DLinkListNode* ret = NULL;  
  294.     list_head* lhead = (list_head* )head;  
  295.     if((NULL != lhead)&&(NULL != lhead->slider)) //保证游标是有效的   
  296.     {  
  297.         ret = lhead->slider;  
  298.         lhead->slider = ret->pre;   
  299.     }  
  300.     return ret;  
  301. }  
  302.   
  303. /******************************************************************************************************* 
  304. 函数名： DLinkList_Del 
  305. 函数功能：删除链表中的某个指定元素  
  306. 参数： DLinkList* head   DLinkListNode* node为指定的元素  
  307. 返回值：成功返回 删除的链表元素  失败返回NULL  
  308. *******************************************************************************************************/  
  309. DLinkListNode* DLinkList_Del(DLinkList* head,DLinkListNode* node)  
  310. {   //这个函数主要是用来删除游标的返回值的   
  311.    
  312.     DLinkListNode* ret = NULL;  
  313.     list_head* lhead = (list_head* )head;  
  314.     int i=0;   
  315.     if((NULL != head)&&(NULL != node))  
  316.     {  
  317.         DLinkListNode* current = (DLinkListNode*)lhead;  
  318.         for(i=1; i<=lhead->length; i++)  
  319.         {  
  320.             if(node == current->next)  
  321.             {  
  322.                 ret = current->next;  
  323.                 break;   
  324.             }   
  325.             current = current->next;  
  326.         }  
  327.           
  328.         if(NULL == ret)  //说明没有找到node   
  329.         {  
  330.             printf("put error!!!\n");   
  331.         }  
  332.         else //找到了node   
  333.         {  
  334.             Del_DLinkListNode(lhead,i);   
  335.             printf("ii%d\n",i);  
  336.         }   
  337.     }     
  338.     return ret;//返回删除的链表元素   
  339. }  
  340.   
  341. /***************************************************************************************************************** 
  342. 函数名： partion 
  343. 函数功能：快速排序的子函数 
  344. 参数： LinkList* pstHead 链表头  LinkListNode* pstLow 开始排序的头指针  LinkListNode* pstHigh  结束排序的尾指针  
  345. 返回值： LinkListNode* partion  返回中值的指针 
  346. 注意：way_id是比较的数据     data是交换的数据  
  347. *****************************************************************************************************************/   
  348. DLinkListNode* partion(DLinkList* pstHead, DLinkListNode* pstLow, DLinkListNode* pstHigh)    
  349. {    
  350.          list* list_pstLow= (list*) pstLow;  
  351.          list* list_pstHigh= (list*) pstHigh;  
  352.          DATA iTmp;    
  353.          unsigned int pivot = 0;    
  354.          pivot = list_pstLow->data.way_id;    
  355.          while ( pstLow != pstHigh )    
  356.          {    
  357.               //从后面往前换    
  358.               while ( (pstLow != pstHigh) && (list_pstHigh->data.way_id >= pivot))    
  359.               {    
  360.                     pstHigh = pstHigh->pre;   
  361.                     list_pstHigh = (list*) pstHigh;  
  362.               }    
  363.               //交换high low    
  364.               iTmp = list_pstLow->data;    
  365.               list_pstLow->data = list_pstHigh->data;    
  366.               list_pstHigh->data = iTmp;    
  367.                
  368.               //从前往后换    
  369.               while ( pstLow != pstHigh && list_pstLow->data.way_id <= pivot )    
  370.               {    
  371.                     pstLow = pstLow->next;   
  372.                     list_pstLow = (list*)pstLow;  
  373.               }    
  374.               //交换high low    
  375.               iTmp = list_pstLow->data;    
  376.               list_pstLow->data = list_pstHigh->data;    
  377.               list_pstHigh->data = iTmp;    
  378.          }    
  379.          return pstLow;    
  380. }    
  381. /***************************************************************************************************************** 
  382. 函数名： quick_sort 
  383. 函数功能：快速排序 
  384. 参数： LinkList* pstHead 链表头指针 LinkListNode* pstLow 开始排序的头指针 LinkListNode* pstHigh  结束排序的尾指针  
  385. 返回值：void  无返回值  
  386. *****************************************************************************************************************/    
  387. void quick_sort(DLinkList* pstHead, DLinkListNode* pstLow, DLinkListNode* pstHigh)    
  388. {    
  389.     DLinkListNode* pstTmp = NULL;    
  390.     pstTmp = partion(pstHead, pstLow, pstHigh);    
  391.     if ( pstLow != pstTmp )    
  392.     {    
  393.          quick_sort(pstHead, pstLow, pstTmp->pre);    
  394.     }    
  395.      if ( pstHigh != pstTmp )    
  396.      {    
  397.         quick_sort(pstHead, pstTmp->next, pstHigh);    
  398.      }    
  399.      
  400. }    


DLinkList.h：

[cpp] view plaincopy
  1. #ifndef __DLinkList_H__  
  2. #define __DLinkList_H__  
  3.   
  4. typedef void DLinkList;  //这个是为了 封装方便   
  5. typedef struct Str_DLinkList DLinkListNode;  //这个结构体是链表的真身   
  6. struct Str_DLinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  7. {                     //转换成(DLinkListNode* )的时候  其实就是要开始对每个元素中的 DLinkListNode进行赋值了   
  8.     DLinkListNode* next;  
  9.     DLinkListNode* pre;  
  10. };  
  11. /**************************************如下参数是为了快速排序罗列的****************************************/  
  12. typedef struct _tag_DATA  
  13. {  
  14.     unsigned int data_length;    //dat中前2个字节  表示一条信息的长度  在用多少个字节   
  15.     unsigned int way_id;         //4个字节  表示道路唯一id   
  16.     unsigned int way_name_length;//2个字节  表示道路名称所占字节数 注意：这个不准   
  17.     unsigned int way_data;       //4个字节  表示道路信息  0~3位表示Class番号   4~6位表示岔路数   7位表示有无flag  
  18.     unsigned char Class;         //way_data & 0000 0000 0000 0000 0000 0000 0000 1111   0x0f  
  19.     unsigned char byroad_num;    //way_data & 0000 0000 0000 0000 0000 0000 0111 0000   0x70  
  20.     unsigned char flag;          //way_data & 0000 0000 0000 0000 0000 0000 1000 0000   0x80  
  21.     char way_name[256];          //data_length-12个字节   表示道路名称   
  22. }DATA;  
  23.   
  24.   
  25. typedef struct _tag_list  
  26. {  
  27.     DLinkListNode head;   
  28.     DATA data;   
  29. }list;  
  30. /****************************************************************************************/  
  31.   
  32. DLinkList* Creat_DLinkListHead(void);  
  33.   
  34. int Destroy_DLinkListHead(DLinkList* head);  
  35.   
  36. int Get_Length(DLinkList* head);  
  37.   
  38. int Clean_DLinkListHead(DLinkList* head);  
  39.   
  40. int Add_DLinkList(DLinkList* head, DLinkListNode* Node, int pos);  
  41.   
  42. DLinkListNode* Get_DLinkListNode(DLinkList* head, int pos);  
  43.   
  44. DLinkListNode* Del_DLinkListNode(DLinkList* head, int pos);   
  45.   
  46. DLinkListNode* DLinkList_Slider(DLinkList* head);  
  47.   
  48. DLinkListNode* DLinkList_Reset(DLinkList* head);  
  49.   
  50. DLinkListNode* DLinkList_Next(DLinkList* head);  
  51.   
  52. DLinkListNode* DLinkList_Pre(DLinkList* head);  
  53.   
  54. DLinkListNode* DLinkList_Del(DLinkList* head,DLinkListNode* node);  
  55.   
  56.    
  57.    
  58. #endif  


main.c：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "DLinkList.h"  
  4.   
  5. typedef struct _tag_str  
  6. {  
  7.     DLinkListNode head;  
  8.     int i;  
  9. }str;  
  10. int main(int argc, char *argv[])  
  11. {  
  12.     int j = 0;  
  13.     DLinkList* list_head;  
  14.     list_head = Creat_DLinkListHead();  
  15.     str str1,str2,str3,str4,str5,str6,*strp;  
  16.     str1.i=1;  
  17.     str2.i=2;  
  18.     str3.i=3;  
  19.     str4.i=4;  
  20.     str5.i=5;  
  21.     str6.i=6;  
  22.   
  23.     Add_DLinkList(list_head, (DLinkListNode*)&str1,12);  
  24.     Add_DLinkList(list_head, (DLinkListNode*)&str2,12);  
  25.     Add_DLinkList(list_head, (DLinkListNode*)&str3,12);  
  26.     Add_DLinkList(list_head, (DLinkListNode*)&str4,12);  
  27.     Add_DLinkList(list_head, (DLinkListNode*)&str5,12);  
  28.       
  29.       
  30. //  Add_DLinkList(list_head, (DLinkListNode*)&str6,0);  
  31.     for(j=1;j<=Get_Length(list_head);j++)  
  32.     {  
  33.         strp = (str* )Get_DLinkListNode(list_head, j);  
  34.         printf("%d\n",strp->i);  
  35.     }  
  36.   
  37.   
  38.     printf("\n");  
  39.     //DLinkList_Reset(list_head);  
  40.     strp = (str* )DLinkList_Slider(list_head);  
  41.     printf("%d\n",strp->i);  
  42.     printf("\n");  
  43.     for(j=1;j<=Get_Length(list_head)-1;j++)  
  44.     {  
  45.         DLinkList_Next(list_head);  
  46.         strp = (str* )DLinkList_Slider(list_head);  
  47.         printf("%d\n",strp->i);  
  48.     }  
  49.       
  50.     DLinkList_Del(list_head,(DLinkListNode*)&str5);  
  51.     printf("\n");  
  52.       
  53.     for(j=1;j<=Get_Length(list_head)-1;j++)  
  54.     {  
  55.         DLinkList_Pre(list_head);  
  56.         strp = (str* )DLinkList_Slider(list_head);  
  57.         printf("%d\n",strp->i);  
  58.     }     
  59.   
  60.       
  61.     Destroy_DLinkListHead(list_head);  
  62.     return 0;  
  63. }  



在前两节的基础上，实现双向循环链表。

本节知识点：

1.双向循环链表的结构：

上面就是双向循环链表的结构图，对于双向链表的插入有3个位置，A、B、C。

但是在插入第一个元素的时候(其实插入第一个元素的时候，就是循环建立的时候)，有些特殊，所以就画了一个图，如下：

本节代码：

DcLinkList.c：

[cpp] view plaincopy
  1. /******************************************************************************************************* 
  2. 文件名：DcLinkList.c 
  3. 头文件：DcLinkList.h  
  4. 时间： 2013/08/26 
  5. 作者： Hao 
  6. 功能:  可以复用 带有增 删 改 查 功能的双向循环链表 
  7. 难道： 1.typedef struct Str_DcLinkList DcLinkListNode;  //这个结构体是链表的真身  
  8.         struct Str_DcLinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型  
  9.         {                     //转换成(DcLinkListNode* )的时候  其实就是要开始对每个元素中的 DcLinkListNode进行赋值了  
  10.             DcLinkListNode* next; 
  11.         };  
  12.         这个链表结构在链表元素中起到的作用 是本节的难点  
  13.         2.切记一个问题  就是已经是链表中元素的 千万不要再往链表中添加了 否则链表一定出现无穷的错误  
  14.         3.对于pos值的问题  add、get、del三个函数中 的链表都是 从1开始的到length  0是链表头  
  15.                           在add函数中pos为0的时候是和pos为1的情况是一样的  都是头插法  0~~~~~无穷大  
  16.                           在get函数中pos为0的时候是获得链表头 地址      0~~~~~length  
  17.                           在del函数中pos为0的时候是无效的 del失败       1~~~~~length  
  18. *******************************************************************************************************/  
  19. #include <stdio.h>  
  20. #include <stdlib.h>  
  21. #include <malloc.h>  
  22. #include "DcLinkList.h"  
  23.   
  24. typedef struct str_list_head  //这个是链表头 其实也可以当作一个没有前驱的 链表元素 元素的内容是链表长度   
  25. {  
  26.     //DcLinkListNode* next;  
  27.     DcLinkListNode head; //这个参数要特别重视 每一个链表元素结构的第一个参数一定是 DcLinkListNode  
  28.                        //因为在寻找链表元素后继的时候 其实就是将链表元素强制类型转换成 DcLinkListNode*  然后给next进行赋值 其实就是给 DcLinkListNode变量赋值   
  29.     DcLinkListNode* slider;   
  30.     int length; //链表长度   
  31. }list_head;  
  32.   
  33. /******************************************************************************************************* 
  34. 函数名： Creat_DcLinkListHead 
  35. 函数功能：创建一个链表的链表头 并给链表头分配空间 
  36. 参数： void 
  37. 返回值：ret 成功返回链表头地址  失败返回NULL  
  38. *******************************************************************************************************/  
  39. DcLinkList* Creat_DcLinkListHead(void)  
  40. {  
  41.     list_head* ret = NULL;  
  42.     ret = (list_head* )malloc( sizeof(list_head)*1 );  
  43.     if(NULL != ret) //malloc分配成功   
  44.     {  
  45.         ret->length = 0;  
  46.         //ret -> next = NULL;  
  47.         ret->head.next = NULL;  
  48.         ret->head.pre = NULL;  
  49.         ret->slider = NULL;  
  50.     }  
  51.     return (DcLinkList* )ret;   
  52. }  
  53.   
  54. /******************************************************************************************************* 
  55. 函数名：Destroy_DcLinkListHead 
  56. 函数功能：释放一个链表头指针  
  57. 参数：DcLinkList* head 链表头指针  
  58. 返回值： ret 释放成功返回1  释放失败返回0  
  59. *******************************************************************************************************/  
  60. int Destroy_DcLinkListHead(DcLinkList* head)  
  61. {  
  62.     int ret = 0;   
  63.     list_head* lhead = (list_head* )head;  
  64.     if( NULL != lhead )  
  65.     {  
  66.         free(lhead);  
  67.         ret = 1;  
  68.     }  
  69.     return ret;  
  70. }  
  71.   
  72. /******************************************************************************************************* 
  73. 函数名:Get_Length 
  74. 函数功能：获得链表的长度  
  75. 参数: DcLinkList* head 链表头指针  
  76. 返回值： ret 成功返回链表长度  失败返回0  
  77. *******************************************************************************************************/  
  78. int Get_Length(DcLinkList* head)   
  79. {  
  80.     int ret = 0;  
  81.     list_head* lhead = (list_head* )head;  
  82.     if( NULL != lhead )  
  83.     {  
  84.         ret = lhead -> length;  
  85.     }     
  86.     return ret;  
  87. }  
  88.   
  89. /******************************************************************************************************* 
  90. 函数名：Clean_DcLinkListHead 
  91. 函数功能：   清空链表  
  92. 参数： DcLinkList* head 链表头指针  
  93. 返回值：ret 成功返回1 失败返回0  
  94. *******************************************************************************************************/  
  95. int Clean_DcLinkListHead(DcLinkList* head)   
  96. {  
  97.     int ret = 0;  
  98.     list_head* lhead = (list_head* )head;  
  99.     if( NULL != lhead )  
  100.     {  
  101.         lhead -> length = 0;  
  102.         //lhead  -> next = NULL;  
  103.         lhead -> head.next = NULL;  
  104.         lhead->head.pre = NULL;  
  105.         lhead->slider = NULL;  
  106.         ret = 1;  
  107.     }     
  108.     return ret;  
  109. }  
  110.   
  111. /******************************************************************************************************* 
  112. 函数名:Add_DcLinkList 
  113. 函数功能：往链表里面添加一个链表元素 如果pos的值是0(就是链表头)和1(链表的第一元素 链表元素个数是从1开始算的)都是头插法 
  114.           pos的值大于链表长度是尾插法  这里面pos值得注意的是 i=1 pos为a的时候 是把链表元素插入第a个元素的位置  
  115.           当i=0 pos为a的时候 是把链表元素插入 第a个元素位置的后面    切忌：这里面0位置是链表头指针 从1开始是链表元素  
  116. 参数：   DcLinkList* head链表头指针    DcLinkListNode* Node插入元素的指针(被强制类型转化成DcLinkListNode*)  int pos 插入位置  
  117.          pos的有效值范围是 从0到无穷大   
  118. 返回值： ret 插入成功返回1  插入失败返回0  
  119. *******************************************************************************************************/  
  120. int Add_DcLinkList(DcLinkList* head, DcLinkListNode* Node, int pos)  
  121. {  
  122.     int ret = 0;  
  123.     int i = 0;  
  124.     list_head* lhead = (list_head* )head;  
  125.     DcLinkListNode* node = (DcLinkListNode* )head;  
  126.     DcLinkListNode* Last = NULL;  
  127.     ret=( NULL != node) && ( NULL != Node) && (pos >= 0);  
  128.     if(1 == ret)  
  129.     {  
  130.         for(i=1; ( (i<pos) && (node->next != NULL) ); i++)  
  131.         {  
  132.             node = node->next;  
  133.         }  
  134.         Node -> next = node -> next;  
  135.         node -> next = Node;  
  136.           
  137.         if(NULL != Node->next)   
  138.         {  
  139.             Node->next->pre = Node;   
  140.         }  
  141.         Node->pre = node;  
  142.           
  143.         if(lhead->length == 0)//第一次插入元素的时候把游标 指向这个元素    
  144.         {  
  145.             lhead->slider = Node;  
  146.         }  
  147.         lhead -> length++; //这个一定要在后面调用 lhead->length值的前面更新   
  148.         /*判断是否为头插法  所谓头插法 就是pos为0和1的情况 其实也就是没有进for循环的情况  剩下的无论pos为多少  进入多少次循环都没有头插法*/  
  149.         if(node == (DcLinkListNode* )head)   
  150.         {  
  151.             Last =(DcLinkListNode* )Get_DcLinkListNode(lhead, lhead->length); //获得链表最后一个元素   
  152.             Last->next = Node; //把头插法的数据连接到 链表的最后一个元素的后面   
  153.             Node->pre = Last;  
  154.         }  
  155.           
  156.     }  
  157.     return ret;  
  158. }  
  159.   
  160. /******************************************************************************************************* 
  161. 函数名：Get_DcLinkListNode 
  162. 函数功能：获得链表中第pos个元素位置的链表元素 链表是从1开始的  0是链表头   pos为0的时候表示get链表头  
  163. 参数： DcLinkList* head链表头指针    int pos获得链表元素的位置  pos的有效取值范围是 1 到  length  0是链表头  
  164. 返回值： DcLinkListNode*类型 第pos个链表元素的地址  
  165. *******************************************************************************************************/  
  166. DcLinkListNode* Get_DcLinkListNode(DcLinkList* head, int pos)  
  167. {  
  168.     int ret = 0;  
  169.     int i = 0;  
  170.     list_head* lhead = (list_head* )head;  
  171.     /*本来pos应该是有上限的  但是变成了循环链表pos理论上说就可以无穷大了  但是get函数应该是在链表中有值的情况下才成立的 即(lhead->length>0)*/   
  172.     ret=( NULL != lhead) && (pos >= 0) && (lhead->length>0);   
  173.     if(1 == ret)  
  174.     {  
  175.         DcLinkListNode* node = (DcLinkListNode* )head;  
  176.         for(i=0; i<pos; i++) //执行 pos次   得到的是第pos位置的node   
  177.         {  
  178.             node = node->next;  
  179.         }     
  180.         return (DcLinkListNode*)node;  
  181.     }  
  182.     return NULL;  
  183. }  
  184.   
  185. /******************************************************************************************************* 
  186. 函数名：Del_DcLinkListNode 
  187. 函数功能：删除链表中第pos位置的链表元素  
  188. 参数： DcLinkList* head链表头指针    int pos删除链表元素的位置  pos是删除的链表元素的位置 跟get和add中的 
  189.        pos是配套的  有效取值范围依然是 1到 length  在这个函数里面由于不能删除链表头 所以pos为0的时候无效  
  190. 返回值： DcLinkListNode* ret这个返回值很重要 因为这个删除仅仅是把链表元素踢出了链表 并没有free开辟的内存 
  191.          应该通过这个返回的地址free  释放内存 
  192.          删除成功返回 删除链表元素的地址   删除失败返回 NULL  
  193. *******************************************************************************************************/  
  194. DcLinkListNode* Del_DcLinkListNode(DcLinkList* head, int pos)  
  195. {  
  196.     DcLinkListNode* ret = NULL;  
  197.     DcLinkListNode* Last = NULL;  
  198.     int i = 0;  
  199.     list_head* lhead = (list_head* )head;  
  200.     DcLinkListNode* first = lhead->head.next;  
  201.       
  202.     if(( NULL != lhead) && (pos > 0) && (lhead->length>0))  
  203.     {  
  204.         DcLinkListNode* node = (DcLinkListNode* )head;  
  205.         for(i=1; i<pos; i++)//执行 pos次   得到的是第pos位置的node  这个方法行不通   
  206.         {                   //因为要想删除第pos位置的node 应该先找到它上一个链表元素   
  207.             node = node->next; //所以这里面i=1 比get函数少执行了一次  得到第pos-1位置的node   
  208.         }  
  209.         /*判断是不是 pos为1的 情况删除头节点后面的第一个元素(这个是没有进入for循环的)  跟循环一圈后的情况不一样  */  
  210.         /*循环一圈的是进入for循环的情况   此时的node不再是head了 而是链表最后一个元素*/   
  211.         if(node == (DcLinkListNode* )head)  
  212.         {  
  213.             Last =(DcLinkListNode* )Get_DcLinkListNode(lhead, lhead->length);  
  214.         }  
  215.           
  216.         ret = node->next;  
  217.         node->next = ret->next;     
  218.         /*判断是不是循环了一圈后回来的情况 */  
  219.         if((first == ret) && (NULL == Last))  
  220.         {  
  221.             Last =(DcLinkListNode* )Get_DcLinkListNode(lhead, lhead->length);  
  222.         }  
  223.         /*判断是否要删除链表中的第一个元素*/  
  224.         if( Last != NULL )  
  225.         {  
  226.             Last->next = ret->next;   
  227.             lhead->head.next = ret->next;  
  228.             ret->next->pre = Last;  
  229.         }  
  230.           
  231.         if(1 != lhead->length) //判断删除的值是否为最后一个元素   
  232.         {  
  233.             ret->next->pre = ret->pre;  
  234.             if(node == (DcLinkListNode* )head)//判断删除的值是否为第一个元素   
  235.             {  
  236.                 ret->next->pre =  Last;  
  237.             }   
  238.             if(lhead->slider == ret) //判断删除的节点是否为游标的位置   
  239.             {  
  240.                 lhead->slider = ret->next;   
  241.             }   
  242.         }   
  243.         lhead->length--; //这个一定要写在 Get_DcLinkListNode 后面 不然的话 pos就为0了   
  244.         /*判断链表是否 减到了空  如果链表中不再有元素 就把head.next赋值为NULL*/  
  245.         /*单向链表不需要这个的原因 是因为单向链表的最后一个元素的next就是NULL 而双向链表没有NULL的了*/  
  246.         if(0 == lhead->length)  
  247.         {  
  248.             lhead->head.next = NULL;  
  249.             lhead->head.pre = NULL;  
  250.             lhead->slider = NULL;   
  251.         }  
  252.           
  253.     }  
  254.     return (DcLinkListNode*)ret;  
  255. }  
  256.   
  257. /******************************************************************************************************* 
  258. 函数名： DcLinkList_Slider 
  259. 函数功能：获得当前游标指向的数据 
  260. 参数： DcLinkList* head 
  261. 返回值：成功返回 DcLinkListNode* ret  失败返回NULL  
  262. *******************************************************************************************************/  
  263. DcLinkListNode* DcLinkList_Slider(DcLinkList* head)  
  264. {  
  265.     DcLinkListNode* ret = NULL;  
  266.     list_head* lhead = (list_head* )head;  
  267.     if( (NULL != lhead)&&(NULL != lhead->slider) )//保证slider是有效的   
  268.     {  
  269.         ret = lhead->slider;  
  270.     }  
  271.     return ret;  
  272. }  
  273.   
  274. /******************************************************************************************************* 
  275. 函数名： DcLinkList_Reset 
  276. 函数功能：重置游标 让游标指向head头节点后面的第一个元素  
  277. 参数： DcLinkList* head 
  278. 返回值：成功返回 当前游标的指向DcLinkListNode* ret  失败返回NULL  
  279. *******************************************************************************************************/  
  280. DcLinkListNode* DcLinkList_Reset(DcLinkList* head)  
  281. {  
  282.     DcLinkListNode* ret = NULL;  
  283.     list_head* lhead = (list_head* )head;  
  284.     if(NULL != lhead)  
  285.     {  
  286.         lhead->slider = lhead->head.next;  
  287.         ret = lhead->slider;  
  288.     }  
  289.     return ret;  
  290. }  
  291.   
  292. /******************************************************************************************************* 
  293. 函数名： DcLinkList_Next 
  294. 函数功能：使游标指向下一个元素  
  295. 参数： DcLinkList* head 
  296. 返回值：成功返回 前游标的指向DcLinkListNode* ret  失败返回NULL  
  297. *******************************************************************************************************/  
  298. DcLinkListNode* DcLinkList_Next(DcLinkList* head)  
  299. {  
  300.     DcLinkListNode* ret = NULL;  
  301.     list_head* lhead = (list_head* )head;  
  302.     if((NULL != lhead)&&(NULL != lhead->slider)) //保证游标是有效的   
  303.     {  
  304.         ret = lhead->slider;  
  305.         lhead->slider = ret->next;   
  306.     }  
  307.     return ret;  
  308. }  
  309.   
  310. /******************************************************************************************************* 
  311. 函数名： DLinkList_Pre 
  312. 函数功能：使游标指向上一个元素  
  313. 参数： DLinkList* head 
  314. 返回值：成功返回 前游标的指向DLinkListNode* ret  失败返回NULL  
  315. *******************************************************************************************************/  
  316. DcLinkListNode* DcLinkList_Pre(DcLinkList* head)  
  317. {  
  318.     DcLinkListNode* ret = NULL;  
  319.     list_head* lhead = (list_head* )head;  
  320.     if((NULL != lhead)&&(NULL != lhead->slider)) //保证游标是有效的   
  321.     {  
  322.         ret = lhead->slider;  
  323.         lhead->slider = ret->pre;   
  324.     }  
  325.     return ret;  
  326. }  
  327.   
  328. /******************************************************************************************************* 
  329. 函数名： DcLinkList_Del 
  330. 函数功能：删除链表中的某个指定元素  
  331. 参数： DcLinkList* head   DcLinkListNode* node为指定的元素  
  332. 返回值：成功返回 删除的链表元素  失败返回NULL  
  333. *******************************************************************************************************/  
  334. DcLinkListNode* DcLinkList_Del(DcLinkList* head,DcLinkListNode* node)  
  335. {   //这个函数主要是用来删除游标的返回值的   
  336.    
  337.     DcLinkListNode* ret = NULL;  
  338.     list_head* lhead = (list_head* )head;  
  339.     int i=0;   
  340.     if((NULL != head)&&(NULL != node))  
  341.     {  
  342.         DcLinkListNode* current = (DcLinkListNode*)lhead;  
  343.         for(i=1; i<=lhead->length; i++)  
  344.         {  
  345.             if(node == current->next)  
  346.             {  
  347.                 ret = current->next;  
  348.                 break;   
  349.             }   
  350.             current = current->next;  
  351.         }  
  352.           
  353.         if(NULL == ret)  //说明没有找到node   
  354.         {  
  355.             printf("put error!!!\n");   
  356.         }  
  357.         else //找到了node   
  358.         {  
  359.             Del_DcLinkListNode(lhead,i);   
  360.         }   
  361.     }     
  362.     return ret;//返回删除的链表元素   
  363. }  


DcLinkList.h：

[cpp] view plaincopy
  1. #ifndef __DcLinkList_H__  
  2. #define __DcLinkList_H__  
  3.   
  4. typedef void DcLinkList;  //这个是为了 封装方便   
  5. typedef struct Str_DcLinkList DcLinkListNode;  //这个结构体是链表的真身   
  6. struct Str_DcLinkList   //每一个链表元素的结构都会包含这个结构  因为当给链表元素强制类型   
  7. {                     //转换成(DcLinkListNode* )的时候  其实就是要开始对每个元素中的 DcLinkListNode进行赋值了   
  8.     DcLinkListNode* next;  
  9.     DcLinkListNode* pre;  
  10. };  
  11.   
  12. DcLinkList* Creat_DcLinkListHead(void);  
  13.   
  14. int Destroy_DcLinkListHead(DcLinkList* head);  
  15.   
  16. int Get_Length(DcLinkList* head);  
  17.   
  18. int Clean_DcLinkListHead(DcLinkList* head);  
  19.   
  20. int Add_DcLinkList(DcLinkList* head, DcLinkListNode* Node, int pos);  
  21.   
  22. DcLinkListNode* Get_DcLinkListNode(DcLinkList* head, int pos);  
  23.   
  24. DcLinkListNode* Del_DcLinkListNode(DcLinkList* head, int pos);   
  25.   
  26. DcLinkListNode* DcLinkList_Del(DcLinkList* head,DcLinkListNode* node);  
  27.   
  28. DcLinkListNode* DcLinkList_Next(DcLinkList* head);  
  29.   
  30. DcLinkListNode* DcLinkList_Pre(DcLinkList* head);  
  31.   
  32. DcLinkListNode* DcLinkList_Reset(DcLinkList* head);  
  33.   
  34. DcLinkListNode* DcLinkList_Slider(DcLinkList* head);  
  35.    
  36. #endif  


main.c：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <malloc.h>  
  4. #include <string.h>  
  5. #include "DcLinkList.h"  
  6.   
  7. typedef struct _tag_str  
  8. {  
  9.     DcLinkListNode head;  
  10.     int i;  
  11. }str;  
  12.   
  13. int main()  
  14. {  
  15.     int i = 0;  
  16.     str str1,str2,str3,str4,str5,str6,*strp;  
  17.     str1.i=1;  
  18.     str2.i=2;  
  19.     str3.i=3;  
  20.     str4.i=4;  
  21.     str5.i=5;  
  22.     str6.i=6;  
  23.     DcLinkList* head = NULL;  
  24.     head = Creat_DcLinkListHead();  
  25.     Add_DcLinkList(head, (DcLinkListNode*)&str1, Get_Length(head)+1);  
  26.     Add_DcLinkList(head, (DcLinkListNode*)&str2, Get_Length(head)+1);  
  27.     Add_DcLinkList(head, (DcLinkListNode*)&str3, Get_Length(head)+1);  
  28.     Add_DcLinkList(head, (DcLinkListNode*)&str4, Get_Length(head)+1);  
  29.     Add_DcLinkList(head, (DcLinkListNode*)&str5, Get_Length(head)+1);     
  30.     Add_DcLinkList(head, (DcLinkListNode*)&str6, 3);      
  31.     for(i = 1; i<=Get_Length(head); i++)  
  32.     {  
  33.         strp = (str*)Get_DcLinkListNode(head, i);  
  34.         printf("%d\n",strp->i);  
  35.     }  
  36.     Del_DcLinkListNode(head, 1);  
  37.     printf("\n");  
  38.       
  39.     for(i = 1+5; i<=Get_Length(head)+5; i++)  
  40.     {  
  41.         strp = (str*)Get_DcLinkListNode(head, i);  
  42.         printf("%d\n",strp->i);  
  43.     }     
  44.       
  45.     printf("\n");  
  46.       
  47.     DcLinkList_Reset(head);  
  48.     for(i = 1; i<=Get_Length(head)*3; i++)  
  49.     {  
  50.         DcLinkList_Pre(head);  
  51.         strp = (str*)DcLinkList_Slider(head);     
  52.         printf("%d\n",strp->i);  
  53.     }  
  54.       
  55.     i = 6;  
  56.     while(i--)  
  57.     {  
  58.         Del_DcLinkListNode(head, i);      
  59.     }  
  60.       
  61.     for(i = 1; i<=Get_Length(head); i++)  
  62.     {  
  63.         strp = (str*)Get_DcLinkListNode(head, i);  
  64.         printf("%d\n",strp->i);  
  65.     }  
  66.       
  67.     Destroy_DcLinkListHead(head);  
  68.     return 0;  
  69. }  
  70.  

  71. 转自yhf19881015的专栏


posted @ 2016-02-19 10:32  伴我前行  阅读(206)  评论(0)  编辑  收藏  举报