笔试常见链表题

view plain copy to clipboard print ?

1. #include <iostream>   
2. using   namespace  std;  
3. struct  Node  
4. {  
5.     int  data;  
6.     Node* next;  
7. };  
8. //检测给定链表是否有环   
9. bool  CheckList( const  Node* MyNode )  
10. {  
11.     if  (MyNode == NULL)  
12.     {  
13.         return   false ;  
14.     }  
15.     const  Node *low = MyNode;  
16.     Node *fast = MyNode->next;  
17.     while  ((fast!=NULL) && (fast->next!=NULL))  
18.     {  
19.         low = low->next;  
20.         fast = fast->next->next;  
21.         if  (low==fast)  
22.         {  
23.             return   true ;     //有环   
24.         }  
25.     }  
26.     return   false ;  
27. }  
28. //查找环入口点   
29. Node* FindLoopPoint(Node* InNode)  
30. {     
31.     bool  bIsLoop =  false ;  
32.     if  (InNode == NULL)  
33.     {  
34.         cout << "loop is null"  << endl;  
35.         return  NULL;  
36.     }  
37.     Node* fptr = InNode;  
38.     Node* sptr = InNode;  
39.     while  (sptr!=NULL && sptr->next!=NULL)  
40.     {  
41.         fptr = fptr->next;  
42.         sptr = sptr->next->next;  
43.         if  (fptr == sptr)  
44.         {  
45.             bIsLoop = true ;  //存在环   
46.             break ;  
47.         }  
48.     }  
49.   
50.     if  (bIsLoop ==  false )  
51.     {  
52.         cout << "no loop"  << endl;  
53.         return  NULL;  
54.     }   
55.     else   
56.     {  
57.         fptr = InNode;  
58.         while  (fptr!=sptr)  
59.         {  
60.             fptr = fptr->next;  
61.             sptr = sptr->next;  
62.         }  
63.         Node *rptr = fptr;  
64.         return  rptr;  
65.     }  
66.   
67. }  
68. //链表逆序--递归   
69. Node* ReverseList(Node *head)  
70. {  
71.     if  (NULL == head)                //没有节点   
72.     {  
73.         return  head;  
74.     }   
75.     else   if  (NULL == head->next)  //只有一个节点   
76.     {  
77.         return  head;  
78.     }   
79.     else   
80.     {  
81.         Node* rHead = ReverseList(head->next);  
82.         head->next->next = head;  
83.         head->next = NULL;  
84.         return  rHead;  
85.     }  
86. }  
87. //链表逆序--非递归   
88. Node* ReverseList2(Node*head)  
89. {  
90.     if  (head == NULL || head->next==NULL)  
91.     {  
92.         return  head;  
93.     }  
94.     Node *p1 = head;  
95.     Node *p2 = head->next;  
96.     Node *p3 = head->next->next;  
97.     p1->next = NULL;  
98.     while (p3 != NULL)  
99.     {  
100.         p2->next = p1;  
101.         p1 = p2;  
102.         p2 = p3;  
103.         p3 = p3->next;  
104.     }  
105.     p2->next = p1;  
106.     head = p2;  
107.     return  head;  
108. }  
109. //已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同   
110. Node* Merge(Node* head1,Node* head2)  
111. {  
112.     if  (NULL == head1)  
113.     {  
114.         return  head2;  
115.     }  
116.     if  (NULL == head2)  
117.     {  
118.         return  head1;  
119.     }  
120.     Node* head;  
121.     Node *p1,*p2;  
122.       
123.     if  (head1->data < head2->data)  
124.     {  
125.         head = head1;  
126.         p1 = head1->next;  
127.         p2 = head2;  
128.     }  
129.     else   
130.     {  
131.         head = head2;  
132.         p1 = head1;  
133.         p2 = head2->next;  
134.     }  
135.   
136.     Node *p3 = head;  
137.     while  (p1!=NULL && p2!=NULL)  
138.     {  
139.         if  (p1->data < p2->data)  
140.         {  
141.             p3->next = p1;  
142.             p3 = p1;  
143.             p1 = p1->next;     
144.         }   
145.         else   
146.         {  
147.             p3->next = p2;  
148.             p3 = p2;  
149.             p2 = p2->next;  
150.         }  
151.     }  
152.   
153.     if  (p1 != NULL)  
154.     {  
155.         p3->next = p1;  
156.     }  
157.     if  (p2 != NULL)  
158.     {  
159.         p3->next = p1;  
160.     }  
161.   
162.     return  head;  
163. }  
164.   
165. //递归   
166. Node* Merge2(Node* head1,Node* head2)  
167. {  
168.     if  (NULL == head1)  
169.     {  
170.         return  head2;  
171.     }  
172.     if  (NULL == head2)  
173.     {  
174.         return  head1;  
175.     }  
176.   
177.     Node* head;  
178.     if  (head1->data < head2->data)  
179.     {  
180.         head = head1;  
181.         head->next = Merge2(head1->next,head2);  
182.     }  
183.     else   
184.     {  
185.         head = head2;  
186.         head->next = Merge2(head1,head2->next);  
187.     }  
188.   
189.     return  head;  
190. }