垃圾代码评析——关于《C程序设计伴侣》9.4——链表（二）

前文链接：http://www.cnblogs.com/pmer/archive/2012/11/21/2781703.html

【重构】

　　首先，什么是链表？无论《C程序设计》还是《C程序设计伴侣》都没有给出清晰准确的定义。
　　不知道什么叫链表，当然不可能正确地写出关于链表的代码，《C程序设计伴侣》中出现为链表安装了一条不伦不类的“义尾”(tail)的怪现象也就不足为怪了。
　　在这里我给出我对链表的定义：链表就是一个指针，这个指针，要么值为NULL，要么指向其中含有另一个链表的数据。
　　当然，链表有很多种，这里的定义只是最简单的一种——单向链表。
　　这个定义明显模仿了n!的定义方法，是一种递归式的定义。这种递归式定义的东西用递归的方法很容易实现。
　　其次，链表结点的描述。

typedef 
   struct
   {
      char name[20];
      float score;
   }
data_t;

typedef 
   struct node
   {
      data_t item ;
      struct node *next ;
   }
node_t;

　　这样就建立了一个抽象的结点类型。这样处理的好处是成功地把数据从结点中在形式上剥离开了，这对代码的结构及可维护性都非常很重要。因为我们知道，在一个糟糕的数据结构上是绝对无法建立良好的代码结构的，而代码的结构糟糕则一定会导致可维护性的下降。
　　选择了链表就是选择了链表的优点而不是选择了链表的劣势，这就和你买辆汽车是用来开的而不是用来推的道理一样。和同样属于线性结构的数组相比，链表的优势是很容易在前面加入结点结点，但在尾部加入结点则要麻烦得多。数组则相反，即使在有足够的预留空间的情况下，不经过一番折腾也很难在数组的开始加入一个数据，但是很容易在数组的尾部加入一个数据（只要事先预留了位置）。
　　既然链表很容易在头部加入结点，通常情况下建立链表也应该选择这种方式——不断地向其中添加数据就行了。代码如下：

1. #include <stdlib.h>
2. #include <stdio.h>
3. 
4. //----------通用函数---------------------//
5. void *my_malloc( size_t );
6. //--------------------------------------//
7. 
8. 
9. //----------“数据”类型----------------//
10. typedef 
11.    struct
12.    {
13.       char name[20];
14.       float score;
15.    }
16. data_t;
17. //-----------关于“数据”的函数-----------//
18. int  input  ( data_t * ) ; 
19. void output ( data_t * ) ; 
20. //---------------------------------------//
21. 
22. 
23. //---------“结点”类型------------------//
24. typedef 
25.    struct node
26.    {
27.       data_t item ;
28.       struct node *next ;
29.    }
30. node_t;
31. //--------“链表”操作函数---------------//
32. void create( node_t ** );
33. void insert( node_t ** ,  node_t * );
34. void print ( node_t * );
35. //--------------------------------------//
36. 
37. 
38. int main( void )
39. {
40.    node_t *head = NULL ; //空链表
41.    
42.    puts("建立链表");
43.    create( &head ); 
44.    //测试 
45.    puts("输出链表");
46.    print( head );
47. 
48.    return 0;
49. }
50. 
51. //-------通用函数定义-------------------//
52. void *my_malloc( size_t size )
53. {
54.    void *p = malloc( size );
55.    if( p == NULL )
56.    {
57.       puts("内存不足");
58.       exit(1); 
59.    }   
60.    return p;
61. }
62. //--------------------------------------//
63. 
64. //---------“数据”操作函数定义---------//
65. int input ( data_t *p_data )
66. {
67.    puts("请输入姓名、成绩：");
68.    if( scanf( "%20s%f" , p_data->name , &p_data->score ) != 2 ) //20很重要 
69.    {
70.       while( (getchar()) != '\n' ) //清空输入缓存 
71.          ;
72.       return 0 ;   
73.    }
74.    return !0 ;
75. }
76. 
77. void output ( data_t *p_data )
78. {
79.    printf ("姓名：%s 成绩：%.2f\n" , p_data->name , p_data->score  ) ;
80. }
81. //--------------------------------------//
82. 
83. 
84. //----------“链表”操作函数定义--------//
85. 
86. void print( node_t *p_node )
87. {
88.    if( p_node != NULL )
89.    {
90.       output ( &p_node->item ); 
91.       print( p_node->next );
92.    }
93. }
94. 
95. void insert( node_t ** p_next ,  node_t * p_node)
96. {
97.    p_node -> next = * p_next ;
98.    * p_next = p_node ;
99. }
100. 
101. void create( node_t **p_next )
102. {
103.    data_t data;
104. 
105.    if( input ( & data ) != 0 )
106.    {
107.       node_t *p_node = my_malloc( sizeof (*p_node) );
108.       p_node->item = data ;
109.       insert( p_next , p_node );//插入结点
110.       create( p_next );//继续 
111.    }
112. }
113. //--------------------------------------//

　　这种写法，由于把“数据”视为结点的一个抽象成员，成功地把“数据”部分的操作与关于链表的操作像油和水一样地分离开来。在开发过程中可以把它们作为两个相对独立的模块开发（即所谓“高内聚低耦合”）。而且即使以后对“数据”部分有所修改，只要接口没有发生改变，链表部分完全不受任何影响。

　　或许有人仍然希望新加入的结点都接到链表的尾部，由于这里的create()函数是一次性从零开始建立链表，所以实现这点也并不困难甚至可以说是非常简单，只需要把create()函数定义中的　　

create( p_next );//继续

改成

create( &(*p_next)->next );   //create( p_next );//继续

就可以了。
　　也就是说，对于一次性建立的链表，压根不需要有tail这种东东。

　　但在实际开发中，并不是总能碰到问题要求一次性建立链表这种“好事”，如果问题要求动态地（非一次性地）从链表尾部加入结点、并且要求从前面删除结点呢？这时才需要在head的基础上再加一个记录尾部结点的tail。但即使这样也不要“首尾两端”，而应该“首尾共济”，大大方方地

typedef 
 struct 
 {
    node_t *head;
    node_t *tail;
 } 
queue_t  ;

好了。
只不过这种东东并不叫链表(Linked list)，而叫Queue(队列)。