关于链表题

看完题结论就是：

链表题我是害怕的，很容易被它绕晕，还伴随着递归

嗯

画图，一定要画图。

给定一单链表A1->A2->A3->......->AN, 转换为A2->A1->A4->A3->.....->AN-1(如果N是偶数），

转换为A1->A3->A2->A5->A4->....->AN(如果N是奇数），要求是只能便利一遍链表。

First Thinking：

考虑的是如果N为偶数

构建的是带头结点的链表，参见上篇日志关于链表

 

view plain copy to clipboard print ?

1. /* 
2. 针对有偶数位的带头结点的链表，采用递归 
3. */  
4. Left* ReserveEven(Left *node)  
5. {  
6.  Left *temp = node->next;  
7.  if(temp->next != NULL)  
8.  {  
9.   Left *p = temp->next;  
10.   temp->next = node;  
11.   node->next = ReserveEven(p);  
12.   return temp;  
13.  }  
14.  temp->next = node;  
15.  node->next = NULL;  
16.  return temp;  
17. }  
18.   
19. /* 
20. 针对有偶数位的带头结点的链表，不用递归 
21. */  
22. Left* ReserveEven2(Left *node)  
23. {  
24.  Left *head = node->next;  
25.  while(node->next->next != NULL)  
26.  {  
27.   Left *next = node->next;  
28.   Left *tmp = next->next;  
29.   next->next = node;  
30.   node->next = tmp->next;  
31.   node = tmp;  
32.  }  
33.  node->next->next = node;  
34.  node->next = NULL;  
35.  return head;  
36. }  

 

---------------------------------------------------------------------------

wks做法

1. 偶数个

如1->2->3->4传入时，调用vswap_inner后

*pp_head指向2->1->4->3,

*dangling指向NULL

2. 奇数个 

如1->2->3->4->5传入时，调用vswap_inner后

*pp_head指向2->1->4->3,

*dangling指向1->...

所以需要在 vswap(Node** pp_head)函数中进行判断even否，如果为奇数，需要将

dangling->next = *pp_head;

*pp_head = dangling;

 

view plain copy to clipboard print ?

1. #include <stdio.h>   
2. #include <stdlib.h>   
3.   
4. typedef int BOOL;   
5. #define FALSE (0)   
6. #define TRUE (!FALSE)   
7. typedef struct _Node Node;   
8.   
9. struct _Node {   
10.     int data;   
11.     Node* next;   
12. };   
13.   
14. Node* node_new(int data, Node* next);  
15. void node_seq_print(Node* node);  
16.   
17. // pp: input as the current head node   
18. // dangling: output only   
19.  // output as the even point   
20. BOOL vswap_inner(Node** pp, Node** dangling) {   
21.       
22.     if(*pp==NULL) {   
23.         return TRUE;   
24.     } else {   
25.         Node* first = *pp;   
26.         Node* rest = first->next;   
27.         Node* ndangling;   
28.         BOOL even = vswap_inner(&rest,&ndangling);   
29.         if(even) {   
30.             *pp=rest;   
31.             *dangling=first;   
32.             return FALSE;   
33.         } else {   
34.             ndangling->next = first;   
35.             first->next = rest;   
36.             *pp=ndangling;   
37.             //*dangling=NULL; // Not useful   
38.             return TRUE;   
39.         }   
40.     }   
41. }   
42.    
43. void vswap(Node** pp_head) {   
44.     Node *dangling = NULL;   
45.     BOOL even = vswap_inner(pp_head,&dangling);   
46.     if(!even) {   
47.         dangling->next = *pp_head;   
48.         *pp_head=dangling;   
49.     }   
50. }   
51.   
52. int main() {   
53.     Node *node = node_new(1,    
54.             node_new(2,    
55.                 node_new(3,    
56.                     node_new(4,    
57.                         node_new(5, NULL)   
58.                         ))));   
59.    
60.     Node *node2 = node_new(1,    
61.             node_new(2,    
62.                 node_new(3,    
63.                     node_new(4, NULL)   
64.                         )));   
65.    
66.     vswap(&node);   
67.     vswap(&node2);   
68.    
69.     node_seq_print(node);   
70.     node_seq_print(node2);   
71.    
72.     return 0;   
73. }   
74.   
75.    
76. Node* node_new(int data, Node* next) {   
77.     Node* node = (Node*)(malloc(sizeof(Node)));   
78.     node->data=data;   
79.     node->next=next;   
80.     return node;   
81. }   
82.    
83. void node_free(Node* node) {   
84.     free(node);   
85. }   
86.    
87. void node_seq_print(Node* node) {   
88.     if(node==NULL) {   
89.         printf("/n");   
90.     } else {   
91.         printf("%d ",node->data);   
92.         node_seq_print(node->next);   
93.     }   
94. }   

转自：http://blog.youkuaiyun.com/jeiwt/archive/2009/12/18/5032145.aspx