【算法题】使用递归和非递归实现单向链表的转置

在阅读的过程中有任何问题，欢迎一起交流

邮箱：[email protected]

QQ：1494713801

问题：

给一个单向链表，把它从头到尾反转过来。比如： a -> b -> c ->d 反过来就是 d -> c -> b -> a 。

分析：

假设每一个node的结构是：

class Node { char value; Node next;}

非递归方式代码如下：

1. void reverse(struct Node **list)

2. {

3.     struct Node *currentp = *list;

4.     struct Node *pleft = NULL;

5.     struct Node *pright = NULL;

6.

7.

8.     while (currentp != NULL) {

9.         pright = currentp->next;

10.         currentp->next = pleft;

11.         pleft = currentp;

12.         currentp = pright;

13.     }

14.     *list = pleft;

15. }

递归的方式代码如下：

1. struct Node* recursive_reverse(struct Node *list)

2. {

3.     struct Node *head = list;

4.     struct Node *p = r_reverse(list);

5.     head->next = NULL;

6.     return p;

7. }

8.

9. struct Node *r_reverse(struct Node *list)

10. {

11.     if (NULL == list || NULL == list->next)

12.         return list;

13.     struct Node *p = r_reverse(list->next);

14.     list->next->next = list;

15.     return p;

16. }

递归的方法其实是非常巧的，它利用递归走到链表的末端，然后再更新每一个node的next 值 (代码倒数第二句)。 在上面的代码中， reverseRest 的值没有改变，为该链表的最后一个node，所以，反转后，我们可以得到新链表的head。

单链表相邻元素转置（非递归）

1. struct Node* recursive_reverse(struct Node *list)

2. {

3.     struct Node *head = list;

4.     struct Node *p = r_reverse(list);

5.     head->next = NULL;

6.     return p;

7. }

8.

9. struct Node *r_reverse(struct Node *list)

10. {

11.     if (NULL == list || NULL == list->next)

12.         return list;

13.     struct Node *p = r_reverse(list->next);

14.     list->next->next = list;

15.     return p;

16. }

4   单链表相邻元素转置（递归）

1. struct Node * recursive_partial_reverse(struct Node *list)

2. {

3.     if (NULL == list || NULL == list->next)

4.         return list;

5.     struct Node *p = list->next;

6.     struct Node *node = recursive_partial_reverse(list->next->next);

7.     list->next->next = list;

8.     list->next = node;

9.     return p;

10. }

参考链接：

http://blog.csdn.net/skylinesky/article/details/760694