Merge ordered linked list

2. Using namespace std;
8. struct ListNode
10. {
12. int m_data;
14. listnode* M_pnext;
16. ListNode (int value,listnode* next = NULL): m_data (value), M_pnext (next) {}
18. };
22. /*
24. Two linked lists such as linked list 1:1->3->5->7->9
26. Linked list 2:2->4->6->8->10
30. As we merge two arrays, the head node of the list 1 is compared with the head nodes of the linked list 2, if the value of the linked List 1 head node is greater than the value of the linked list 2 header point,
32. Then the first node of the list 2 is the head node of the consolidated list, then the head nodes of the list 1 continue and the second nodes of the linked List 2 (the head nodes of the remaining list 2)
34. For comparison, but after a linked list has been traversed, if another linked list has not been traversed, because the linked list is already sorted, so let the merge list
36. The tail node points to the head nodes that have not traversed the linked list.
40. As an example:
44. Linked list 1:1,3,5,23,34;
46. Linked list 2:2,4,6,8,10;
48. After traversing the list 3:1,2,3,4,8,10, the list 2 has been traversed, while the loop exits, but the remaining list 1 has 23,34
50. At this point let the tail node of the list 3 10 link The remaining list of the head node 23 will be able to
52. */
56. listnode* MergeList2 (listnode* head1,listnode* head2)
58. {
60. if (head1 = = NULL)
62. {
64. return head2;
66. }
68. Else if (head2 = = NULL)
70. {
72. return head1;
74. }
78. listnode* mergehead = NULL;
80. if (Head1->m_data < Head2->m_data)
82. {
84. Mergehead = Head1;
86. Head1 = head1->m_pnext;
88. }
90. Else
92. {
94. Mergehead = head2;
96. Head2 = head2->m_pnext;
98. }
100. listnode* Tmpnode = Mergehead;
102. While (head1&&head2)
104. {
106. if (Head1->m_data < Head2->m_data)
108. {
110. Mergehead->m_pnext = Head1;
112. Head1 = head1->m_pnext;
114. }
116. Else
118. {
120. Mergehead->m_pnext = head2;
122. Head2 = head2->m_pnext;
124. }
126. Mergehead = mergehead->m_pnext;
128. }
130. if (head1)
132. {
134. Mergehead->m_pnext = Head1;
136. }
138. if (head2)
140. {
142. Mergehead->m_pnext = head2;
144. }
148. return tmpnode;
152. }
154. int _tmain (int argc, _tchar* argv[])
156. {
158. listnode* pHead1 = new ListNode (1);
160. listnode* pcur = pHead1;
162. For (int i = 3; i <; i+=2)
164. {
166. listnode* Tmpnode = new ListNode (i);
168. Pcur->m_pnext = Tmpnode;
170. Pcur = Tmpnode;
172. }
176. listnode* pHead2 = new ListNode (2);
178. Pcur = pHead2;
180. For (int j = 4; J < j+=2)
182. {
184. listnode* Tmpnode = new ListNode (j);
186. Pcur->m_pnext = Tmpnode;
188. Pcur = Tmpnode;
190. }
194. listnode* head = MergeList2 (phead1,phead2);
196. While (head)
198. {
200. cout<"";
202. head=head->m_pnext;
204. }
210. GetChar ();
212. return 0;
214. }</span>

Merging ordered lists