单链表任意交换两节点

来源http://blog.csdn.net/huangxy10/article/details/8014009

思路：

有两种情况，相邻和不相邻。

首先找两个节点的前驱，可以通过前驱来判断是否相邻。

相邻则改变3个结点的next指针，不相邻则改变4个结点的next指针。

 

注意：

要判断许多出错的情况，比如，结点不在表中，结点为空，表为空等。

[cpp]  view plain copy print ?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include <iostream>  
6. #include <string>  
7. using namespace std;  
8.   
9. //链表的结构体  
10. struct node  
11. {  
12.     char val;  
13.     node * next;  
14. };  
15.   
16. //建立链表  
17. struct node * create( string & str_link )  
18. {  
19.     int len = str_link.length();  
20.   
21.     struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素  
22.     struct node * preNode = phead;  
23.     for( int i=0; i<len; i++ )  
24.     {  
25.         struct node * pNode = new node();  
26.         pNode->val = str_link[i];  
27.         pNode->next = NULL;  
28.         preNode->next = pNode;  
29.         preNode = pNode;  
30.     }  
31.     return phead;  
32. }  
33.   
34. //输出链表  
35. void out_link( struct node * phead )  
36. {  
37.     if( phead == NULL )  
38.         return;  
39.     struct node * pNode = phead->next;  
40.     while( pNode )  
41.     {  
42.         cout <<pNode->val;  
43.         pNode = pNode->next;  
44.     }  
45.     cout << endl;  
46. }  
47.   
48. //找到第index个元素  
49. struct node * find_node(struct node* phead, int index )  
50. {  
51.     if(!phead) return NULL;  
52.     struct node * pNode = phead;  
53.     while( index--)  
54.     {  
55.         pNode = pNode->next;  
56.         if( !pNode )  
57.             return NULL;  
58.     }  
59.     return pNode;  
60. }  
61.   
62. //找前驱节点  
63. struct node* find_preNode( struct node* phead, struct node* pNode)  
64. {  
65.     if( !pNode ) return NULL;  
66.     struct node* preNode = phead;  
67.     while( preNode )  
68.     {  
69.         if( preNode->next == pNode )  
70.             return preNode;  
71.         preNode = preNode->next;  
72.     }  
73.     return NULL;  
74. }  
75.   
76. //交换节点  
77. void exchange_node( struct node* phead, struct node* pNode1, struct node* pNode2)  
78. {  
79.     if( !phead ) return;  
80.     //分别找到pNode1的前驱pPre1,和pNode2的前驱pPre2  
81.     struct node* pPre1 = find_preNode( phead, pNode1);  
82.     struct node* pPre2 = find_preNode( phead, pNode2);  
83.     if( !pPre1 || !pPre2 ) return;  //有任何一个没有找到  
84.   
85.     //相邻的情况  
86.     struct node *pBefore, *pAfter, *pPre;  
87.     if( pPre2 == pNode1 )  
88.     {  
89.         pBefore = pNode1;  
90.         pAfter = pNode2;  
91.         pPre = pPre1;  
92.     }  
93.     if( pPre1 == pNode2)  
94.     {  
95.         pBefore = pNode2;  
96.         pAfter = pNode1;  
97.         pPre = pPre2;  
98.     }  
99.     if( pPre2 == pNode1 || pPre1 == pNode2 )  
100.     {  
101.         pPre->next = pAfter;  
102.         pBefore->next = pAfter->next;  
103.         pAfter->next = pBefore;  
104.     }  
105.     else  
106.     {  
107.         //不相邻的情况  
108.         struct node *pNext1 = pNode1->next;  
109.         pNode1->next = pNode2->next;  
110.         pPre1->next = pNode2;  
111.         pPre2->next = pNode1;  
112.         pNode2->next = pNext1;  
113.     }  
114.   
115. }  
116.   
117. void test()  
118. {  
119.     string str;  
120.     cin >> str;  
121.     struct node *phead = create( str );  
122.       
123.     int index;  
124.     cin >> index;  
125.     struct node * pNode1 = find_node( phead, index );  
126.     cin >> index;  
127.     struct node * pNode2 = find_node( phead, index );  
128.     exchange_node( phead, pNode1, pNode2 );  
129.     cout << "after exchange: "<<endl;  
130.     out_link( phead );  
131.   
132. }  
133.   
134. int _tmain(int argc, _TCHAR* argv[])  
135. {  
136.     test();  
137.     return 0;  
138. }