垃圾代码评析——关于《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(队列)。
