防御性编程习惯:求出链表中倒数第 m 个结点的值及其思想的总结

防御性编程习惯

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

看下面的例子

输入一个链表,输出链表中倒数第 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 个结点的位置。

防御性编程习惯:求出链表中倒数第 m 个结点的值及其思想的总结

代码如下:

防御性编程习惯:求出链表中倒数第 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 }
防御性编程习惯:求出链表中倒数第 m 个结点的值及其思想的总结

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

第一、貌似程序的开始,并没有进行判空操作,如果传入的是空链表,也就是 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

防御性编程习惯:求出链表中倒数第 m 个结点的值及其思想的总结
 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 }
防御性编程习惯:求出链表中倒数第 m 个结点的值及其思想的总结

继续分析,提炼思想

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

思考:

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

比如一个问题:判断一个单链表是否有环?

思考

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

小结:

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

 

辛苦的劳动,转载请注明出处,谢谢……
http://www.cnblogs.com/kubixuesheng/p/4391357.html
上一篇:少儿编程妙小程完成近千万美元A轮融资,创世伙伴领投


下一篇:virt-manager中为centos 7.2 扩容根分区