防御性编程习惯

程序员在编写代码的时候，预料有可能出现问题的地方或者点，然后为这些隐患提前制定预防方案或者措施，比如数据库发生异常之后的回滚，打开某些资源之前，判断图片是否存在，网络断开之后的重连次数或者是否连接备用网络，除法运算中的除数问题，函数或者类在接受数据的时候的过滤情况，比如如果输入一个指针参数，是否需要判断是不是空指针？输入一个字符串参数，是否需要判断字符串空否……总的来说就是防止出现不可预见的事情，设计出鲁棒性的代码。

看下面的例子

输入一个链表，输出链表中倒数第 m 个结点额内容，要求从1开始计数，也就是说，链表的尾结点是倒数第一个结点，例如链表一共有6个结点，从头结点开始：1、2、3、4、5、6.链表的倒数第三个结点的值为4。

typedef struct Node{
    int data;
    Node *next;
} Node, *List;

思考：

1、最直接的思路就是从链表的末尾开始，回溯到第 m 个结点，但是给出的链表结构里这是单链表，而单链表的 next 指针是从前到后指向的，这个思路是非常不方便的，可以说行不通。

2、那么逆向的不行，就看看正向的，可以把求倒数第 m 个结点转换为求正数第 x 个结点的问题，假设链表有 n 个结点，那么倒数第 m 个结点就是从头开始的正数第 n-m+1个结点，也就是说，知道了表长，然后通过 n-m+1这个数据，就能找到倒数第 m 个结点的位置。也就是需要从头到尾遍历链表，求出表长 n，然后再从头到尾遍历链表，找到 n-m+1个位置即可。代码很容易写出，但是并不是最好的解法。

继续分析第2个思路，求得改进

原思路是需要遍历两次链表的，显然有些臃肿了，那么如果就要求只遍历一次链表就能实现上述要求，就需要思考下改进方法。那就一次定义两个指示指针，让第一个指针和第二个指针的距离相差 m-1个结点就行了，这样，两个指针同步走，当第一个指针走到最后一个结点的时候，第二个指针刚刚走到倒数第 m 个结点的位置。

代码如下：

 1 //找到倒数第 m 个结点，返回它
 2 Node * getMNode(List head, int m)
 3 {
 4     //第一个指针，在前面遍历链表
 5     Node *forward = head;
 6     //第二个指针，在后面保持距离，然后跟随
 7     Node *behind = NULL;
 8     //先让第一个指针 forward 走 m-1步
 9     for (int i = 0; i < m - 1; i++) {
10         forward = forward->next;
11     }
12     //第一个指针走到第 m-1位置的时候，behind 指针开始和 forward 保持同步移动
13     behind = head;
14     //两个指针开始同步遍历
15     while (behind != NULL) {
16         forward = forward->next;
17         behind = behind->next;
18     }
19     //当 forward 遍历到末位的时候，behind 就是要找的位置，倒数第 m 个结点的位置
20     return behind;
21 }

继续分析第二个思路，测试代码的鲁棒性

第一、貌似程序的开始，并没有进行判空操作，如果传入的是空链表，也就是 head 是 NULL 指针，如果继续运行，那么代码访问了空指针指向的内存，程序就会发生奔溃。

第二、如果链表的长度 n 比 m 还要小，这样肯定不符合逻辑，需要提前判断和预防（防御性的编程习惯），因为程序里有 for 循环，第一个指针会先走 m-1步，如果n 比 m 小，那么for 循环那里肯定出错，仍是空指针的问题。

第三，这里的函数形参里的 m，声明的是 int 类型，如果声明为了无符号 unsigned int 类型，显然，在fou 循环里，m-1语句有风险！如果 m 本身就是0，则 m-1为-1，类型转换为无符号数，反正肯定不是-1。因此 for 循环的次数不是我们想要的结果。同样程序出现崩亏。

改进的建议

1、如果输入的链表为空表，那么程序直接返回 NULL 处理

2、如果链表程度 n 比 m 小，那么在for 循环语句里，需要if判断一下，查看何时出现 next 等于 null的时候，提前避免空指针错误。

3、对于输入0，代码中函数参数写的是 int 类型，虽然无碍，但是实际上，求倒数第0个结点是没有意义的，因为假定是从1开始的，那么此时也可以返回 null

 1 //找到倒数第 m 个结点，返回它
 2 Node * getMNode(List head, int m)
 3 {
 4     //进行空表判断
 5     if (NULL == head || 0 == m) {
 6         return NULL;
 7     }
 8     //第一个指针，在前面遍历链表
 9     Node *forward = head;
10     //第二个指针，在后面保持距离，然后跟随
11     Node *behind = NULL;
12     //先让第一个指针 forward 走 m-1 步
13     for (int i = 0; i < m - 1; i++) {
14         //判断是否越界
15         if (forward->next != NULL) {
16             forward = forward->next;
17         }else{
18             return NULL;
19         }
20     }
21     //第一个指针走到第 m-1位置的时候，behind 指针开始和 forward 保持同步移动
22     behind = head;
23     //两个指针开始同步遍历
24     while (behind != NULL) {
25         forward = forward->next;
26         behind = behind->next;
27     }
28     //当 forward 遍历到末位的时候，behind 就是要找的位置，倒数第 m 个结点的位置
29     return behind;
30 }

继续分析，提炼思想

比如有问题：求链表的中间结点，如果链表结点 n 为奇数，就是返回中间结点，如果结点n 是偶数，那就返回中间结点两个之间的任意一个结点。

思考：

题目是让求中间结点的，那么可以遍历整个链表，求得长度 n，然后判断奇偶性，求得中间结点。其实按照上题的思想，本题同样可以定义两个指针，同时从链表的头结点出发，同步移动，第一个指针 a一次走一步，第二个指针b一次走两步，当走的快的指针到末位结点的时候，走的慢的指针刚刚处在中间位置，（因为a 每次移动都比 b 快1步，而 a 每次走2步，走到了末位的时候，b 其实刚刚走了一半的路程）省去了求n 和判断与计算的过程。

比如一个问题：判断一个单链表是否有环？

思考

有环，说明链表如果一直遍历下去，会回到出发位置。同样，还是定义两个指针，同时从头结点出发，一个指针a一次走一步，另一个指针b一次走两步，如果走的快的b指针反而还追上了走得慢的 a 指针（b 每次两步，如果走到了末位，那么 a 才走到中间，b 继续走就回到了出发点，此时 b 和 a 相距一半的路程，那么 b 继续走，一定会追上 a，且是在起点位置），此时说明链表有环存在，如果走的快的指针走了两圈都没有追上走的慢的a 指针，说明链表没有环结构。

小结：

当处理链表问题的时候，一个指示指针解决不了问题，可以尝试使用两个指示指针，一个走的快点，一个走的慢点，随机应变是同步还是说等待哪个先走，这样可以另辟蹊径去解决问题。