Viết một hàm Sắp xếp [] có hai danh sách, mỗi danh sách được sắp xếp theo thứ tự tăng lên và hợp nhất hai người lại với nhau thành một danh sách theo thứ tự tăng lên. SortedMerge [] sẽ trả về danh sách mới. Danh sách mới nên được thực hiện bằng cách ghép các nút của hai danh sách đầu tiên.
Ví dụ: nếu danh sách được liên kết đầu tiên A là 5-> 10-> 15 và danh sách được liên kết khác B là 2-> 3-> 20, thì Sett 3-> 5-> 10-> 15-> 20.
Có nhiều trường hợp để giải quyết: 'A' hoặc 'B' có thể trống, trong quá trình xử lý 'A' hoặc 'B' có thể hết trước, và cuối cùng, có vấn đề bắt đầu danh sách kết quả trống và xây dựng Nó lên trong khi đi qua 'A' và 'B'.
Phương pháp 1 [sử dụng các nút giả] & nbsp; Chiến lược ở đây sử dụng nút giả tạm thời làm bắt đầu danh sách kết quả. Đuôi con trỏ luôn chỉ vào nút cuối cùng trong danh sách kết quả, vì vậy việc nối thêm các nút mới rất dễ dàng. & NBSP;
The strategy here uses a temporary dummy node as the start of the result list. The pointer Tail always points to the last node in the result list, so appending new nodes is easy.
Nút giả cung cấp cho đuôi một cái gì đó để chỉ vào ban đầu khi danh sách kết quả trống. Nút giả này là hiệu quả, vì nó chỉ là tạm thời và nó được phân bổ trong ngăn xếp. Vòng lặp tiến hành, loại bỏ một nút khỏi ‘A, hoặc‘ B, và thêm nó vào đuôi. Khi & nbsp;
Chúng tôi đã hoàn thành, kết quả là trong dummy.next. & Nbsp;
Hình ảnh dưới đây là một hoạt động khô của phương pháp trên:
Dưới đây là việc thực hiện phương pháp trên: & nbsp;
C++
#include
using namespace std;
class Node
{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 11] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 21] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 81] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 400
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 401
{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 404
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 406
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 408
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 #include 11] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4#include 5 #include 6
#include 4{
#include 9using0
#include 9using2using3
#include 4using5
#include 4using7 #include 5 using9
#include 4{
#include 9namespace3
#include 9using2using3
#include 4using5
#include 4#include 5 std;1
#include 9std;3
#include 4using7
#include 9std;7
#include 4std;9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3class4using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 class7{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 2Node 31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 9using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 { 21] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 { 4{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ 7{ 8 { 91] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 05using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 08{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 121] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 161] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17using3#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 201] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using5using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 25{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 281] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 301] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 321] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 341] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 361] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 381] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 401] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 421] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 441] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 461] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 481] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 49using31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 521] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 55using5
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 571] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 591] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 611] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 651] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 681] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 691] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 711] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 751] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 811] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 851] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 881] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 901] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 931] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 98#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4002
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7 #include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4011
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4015
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4025
#include 4using7
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4029
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4031
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4036
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 711] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4043
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4047
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0Node 2List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4050
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4052
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4054
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4056
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4059
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4061
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4063
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4067
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4071
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 407272.
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4079
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4081
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4083
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4088
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4092
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4098
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4099
#include 4#include 01
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 #include 061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 #include 101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 #include 131] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 #include 161] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 181] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 201] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 221] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 241] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 261] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 281] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 301] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 49#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 371] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 #include 40List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Java
#include 42 #include 43
class Node
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 651] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 51____10#include 53
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 #include 55#include 56#include 57#include 58#include 59
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
class #include 62
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 64
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 #include 671] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10#include 5 #include 71#include 58#include 73
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 77
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using7 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 85
#include 4#include 0 #include 88#include 58#include 73
#include 9#include 92
#include 4#include 94
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 #include 991] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 851] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 using05#include 58#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4using11
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17#include 35#include 4#include 92
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using19List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 using22 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 using241] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10using27{ 8 using29
____10using31{ 8 using29
____10using35{ 8 #include 53using38using39
____10using35{ 8 #include 53using444using39
____10using35{ 8 #include 53using50using39
____10using53{ 8 #include 53using56using39
____10using53{ 8 #include 53using62using39
____10using53{ 8 #include 53using68using39
____10using71{ 8 using73
using74using75
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using77List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
class using81
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62using83
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10using86{ 8 #include 53using89#include 35
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using921] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
using96using971] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 5namespace022358#include 73
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace08
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5namespace16#include 58#include 73
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace22
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5namespace30
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace22
#include 9namespace36
#include 4using5
#include 4using7
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace08
#include 9namespace46
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4namespace50
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 namespace55List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Python3
class namespace59
____10namespace61 namespace62namespace63namespace64
#include 4namespace63namespace67namespace68 namespace69
#include 4namespace63namespace72 ____573 namespace68 namespace75
class namespace77
____10namespace61 namespace62namespace63namespace82
#include 4namespace63namespace85namespace68 namespace75
____10namespace61
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
namespace63namespace82#include 4namespace94namespace68 namespace63namespace97
#include 4#include 0 std;00
#include 9std;02std;03namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17#include 73#include 9namespace94namespace68 std;10namespace73
____10namespace61 std;14namespace63std;16
#include 4std;18namespace68 std;20
#include 4#include 5 namespace63namespace85std;25 namespace75
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9namespace63namespace85namespace68 std;32
#include 9class3
#include 4std;36namespace68 namespace63namespace97
#include 4#include 0 std;42namespace73
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9std;36namespace68 std;42namespace73
#include 4std;42namespace73 namespace68 std;32
namespace61 std;56
____10std;58namespace68 #include 53using89#include 73
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0std;64namespace68 std;661] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 std;691] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 4#include 5 std;73std;25 namespace75
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9std;78namespace73 namespace68 std;81
#include 9using2
#include 4#include 5 std;86std;25 namespace75
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9std;78namespace73 namespace68 std;94
#include 9using2
#include 4#include 5 std;99namespace68 class01
#include 9std;78namespace73 namespace68 std;94
#include 4#include 5 std;99namespace68 class01
#include 4using7
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9std;78namespace73 namespace68 std;81
#include 9std;86namespace68 class23namespace73
#include 4std;64namespace68 std;78namespace73
____10class3 class32namespace73
class34namespace68 class36
class37namespace68 class36
class40using38#include 73
class40using44#include 73
class40using50#include 73
class49using56#include 73
class49using62#include 73
class49using68#include 73
class58namespace68 class60
std;02
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
class63#include 73class65
C#
using class67
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____11 class Node 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 class80#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 #include 531] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 class85#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9class89
#include 9#include 57#include 58
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____11 class #include 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4#include 64
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 #include 67#include 4{
#include 9#include 5 #include 71#include 58using97
#include 9{
Node 19Node 20
#include 9using5
#include 9using7
#include 9{
Node 19Node 28
Node 19#include 0 #include 88#include 58using97
Node 34Node 35
Node 19Node 37
#include 9using5
#include 4using5
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 Node 44#include 4{
#include 9Node 28
#include 9#include 0 using05#include 58using97
#include 9{
Node 56Node 57
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17Node 59Node 19Node 35
#include 9using5
#include 9Node 65
#include 4using5
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 using22 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 Node 72#include 4{
#include 9using27{ 8 Node 78
#include 9using31{ 8 Node 78
#include 9using35{ 8 Node 86
#include 9using35{ 8 Node 90
#include 9using35{ 8 Node 94
#include 9using53{ 8 Node 98
#include 9using53{ 8 { 02
#include 9using53{ 8 { 06
#include 9using71{ 8 using73
{ 11{ 12
#include 9{ 14
#include 4using5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____11 class { 221] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____11 { 271] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4using86{ 8 { 33
#include 4{ 35
#include 4#include 0
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
using96using97#include 4{
#include 9#include 5namespace02#include 58using97
#include 9{
Node 19{ 51
Node 19using2using3
#include 9using5
#include 9#include 5namespace16#include 58using97
#include 9{
Node 19{ 65
Node 19using2using3
#include 9using5
#include 9#include 5{ 73
#include 9{
Node 19{ 65
Node 19{ 79
#include 9using5
#include 9using7
#include 9{
Node 19{ 51
Node 19{ 89
#include 9using5
#include 9{ 93
#include 4using5
#include 4class3 { 98
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using5using5
JavaScript
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0021] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 011#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 014#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0201] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0221] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 026#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0301] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62Các
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0431] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0511] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 053#include 4#include 0 #include 88#include 58#include 73
#include 9#include 92
#include 4#include 94
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 99
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0511] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0531] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 using05#include 58#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0801] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17#include 35#include 4#include 92
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0881] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 089#include 35List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 093 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 097{ 8 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0991] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
using96#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 5namespace02#include 58#include 73
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace08
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5namespace16#include 58#include 73
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace22
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5namespace30
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace22
#include 9namespace36
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9namespace08
#include 9namespace46
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4namespace50
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 namespace55List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 166{ 8 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1681] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 169{ 8 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 168using35{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 174using35{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 177using35{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 180using53{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 183using53{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 186using53{ 8
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1891] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1901] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 191using751] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0881] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 194#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1961] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 197Đầu ra: & nbsp;
Merged Linked List is: 2 3 5 10 15 20
Phương pháp 2 [sử dụng các tài liệu tham khảo cục bộ] & nbsp; giải pháp này có cấu trúc rất giống với ở trên, nhưng nó tránh được bằng cách sử dụng một nút giả. Thay vào đó, nó duy trì một con trỏ cấu trúc ** con trỏ, LastPtrref, luôn chỉ vào con trỏ cuối cùng của danh sách kết quả. Điều này giải quyết trường hợp tương tự mà nút giả đã làm - xử lý danh sách kết quả khi nó trống. Nếu bạn đang cố gắng xây dựng một danh sách ở đuôi của nó, có thể sử dụng nút giả hoặc nút cấu trúc ** Tài liệu tham khảo có thể được sử dụng [xem Phần 1 để biết chi tiết]. & NBSP;
This solution is structurally very similar to the above, but it avoids using a dummy node. Instead, it maintains a struct node** pointer, lastPtrRef, that always points to the last pointer of the result list. This solves the same case that the dummy node did — dealing with the result list when it is empty. If you are trying to build up a list at its tail, either the dummy node or the struct node** “reference” strategy can be used [see Section 1 for
details].
C++14
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1981] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 206#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 209#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 211#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7 #include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 220#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 222#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 232#include 4using7
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 236#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2381] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 811] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 206#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 209#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 211#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7 #include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 220#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 222#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 232#include 4using7
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 236#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2381] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2991] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 302#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 811] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 201#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 318#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 236#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 331#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 341#include 4using7
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 345#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3471] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Python3
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 811] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 310namespace821] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 203#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 9using2using3
Java
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 9using2using3
#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 314#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 404#include 4using7
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 407#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 409#include 4using7 #include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 327#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3111] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 418C#
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2991] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 302#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 201#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 318#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 236#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 331#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4023
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 341#include 4using7
#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 345#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3471] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0021] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 811] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 477#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 480#include 0
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 931] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using2List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 9using2
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3311] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using2List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3391] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3411] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 3451] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 347List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 197
Phương pháp 3 [sử dụng đệ quy] & nbsp; hợp nhất là một trong những vấn đề đệ quy tốt đẹp trong đó mã giải pháp đệ quy sạch hơn nhiều so với mã lặp. Tuy nhiên, bạn có thể muốn sử dụng phiên bản đệ quy cho mã sản xuất, bởi vì nó sẽ sử dụng không gian ngăn xếp tỷ lệ với độ dài của danh sách. & NBSP; & NBSP;
Merge is one of those nice recursive problems where the recursive solution code is much cleaner than the iterative code. You probably wouldn’t want to use the recursive version for production code, however, because it will use stack space which is proportional to the length of the lists.
C++
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 401
{
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5401] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 5 #include 6#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5461] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using7 #include 5 using9#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5531] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 5 std;11] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 560#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0{ #include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 570#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5721] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using51] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 418using5
C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 771] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 791] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5841] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5861] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586#include 5 #include 61] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 592class31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586using7 #include 5 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5981] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 592class31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6011] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586#include 5 std;11] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5861] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5921] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6081] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5921] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586using7 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5861] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5921] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6181] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 5921] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6201] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 586class31] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 243List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Java
class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6281] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____11 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6321] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 637#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 639class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641Các
#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 651#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 655#include 9class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 648#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 666#include 9class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Python3
class namespace59
____10namespace61 namespace62namespace63namespace64
#include 4namespace63namespace67namespace68 namespace69
#include 4namespace63namespace72 ____573 namespace68 namespace75
class namespace77
____10namespace61 namespace62namespace63namespace82
#include 4namespace63namespace85namespace68 namespace75
____10namespace61
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
namespace63namespace82#include 4namespace94namespace68 namespace63namespace97
#include 4#include 0
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 717#include 9std;02std;03namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 722#include 73#include 9namespace94namespace68 std;10namespace73
____10namespace61
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 731namespace631] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 733#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 735namespace68 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 737#include 4#include 5 namespace63namespace85std;25 namespace75
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9namespace63namespace85namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 749#include 9class3
#include 4std;36namespace68 namespace63namespace97
#include 4#include 0 std;42namespace73
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 9std;36namespace68 std;42namespace73
#include 4std;42namespace73 namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 749namespace61
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 773____10namespace94namespace68 namespace75
____10#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 780std;25 namespace751] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 786____10#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 789std;25 namespace751] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 795____10#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 798namespace68 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 800#include 4namespace94namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 795#include 4std;10namespace73 namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 809namespace731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8111] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2#include 4namespace94namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 786#include 4std;10namespace73 namespace68
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 823namespace73#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 828#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 830namespace68namespace68 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8331] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 2____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 836namespace68 class361] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 840using44#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 840using68#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8401] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 849#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8401] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 853#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8401] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 857#include 73____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 860namespace68 class361] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 864using38#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 864using50#include 73____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8641] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 873#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8641] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 877#include 731] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8641] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 881#include 73____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 884namespace68 class36____10
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 888namespace68 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8901] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0std;02List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 895namespace681] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 8971] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 899C#
using class67
class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9031] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9051] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 637#include 58#include 73#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641____10#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 644#include 58using97#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6481] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 5 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6511] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 929#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6481] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0using71] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 940#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6411] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
____10#include 5 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 644#include 58using97
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 002#include 4class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 6481] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 5 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 651JavaScript
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____101093 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 951#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 637#include 58#include 73#include 9class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 655#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 637#include 58#include 73#include 9class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641#include 9
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 666JavaScript
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1971] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0____101093 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 951Time Complexity: Since we are traversing through the two lists fully. So, the time complexity is O[m+n] where m and n are the lengths of the two lists to be merged.
#include 4#include 5 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 637#include 58#include 73
#include 9class3
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 641reversing both the given lists and after reversing, traversing both the lists till the end and then comparing the nodes of both the lists and inserting the node with a larger value at the beginning of the result list. And in this way we will get the resulting list in increasing
order.1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. #include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 644#include 58#include 73#include 9class3 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 648
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9901] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 991#include 4#include 5
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 970#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 977 ____47 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62& nbsp; độ phức tạp về thời gian: & nbsp; vì chúng tôi đang đi qua hai danh sách đầy đủ. Vì vậy, độ phức tạp về thời gian là O [M+N] trong đó M và N là độ dài của hai danh sách sẽ được hợp nhất. & NBSP;
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40001
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40002
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62Phương pháp 4 [đảo ngược danh sách]
Ý tưởng này bao gồm lần đầu tiên đảo ngược cả danh sách đã cho và sau khi đảo ngược, đi qua cả hai danh sách cho đến cuối và sau đó so sánh các nút của cả hai danh sách và chèn nút có giá trị lớn hơn ở đầu danh sách kết quả. Và theo cách này, chúng tôi sẽ nhận được danh sách kết quả theo thứ tự tăng lên.
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40011
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40013
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40015
Dưới đây là việc thực hiện giải pháp trên.
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40020
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62C
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40025
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40027
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40029
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 992 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 997#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40037
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40039
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 68#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40050
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40052
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 5 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40006
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40037
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40039
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4class3
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40050
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40052
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40018
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40023
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40032
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40102
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40103
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40105
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40035
#include 4using7
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40114
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4072
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4074
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40118
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40120
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40122
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40063
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40076
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40134
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40136
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40138
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40140
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40142
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40144
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40146
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40150
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40153
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40157
#include 35
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40160
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40162
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4096
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4069
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40166
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 371] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40094
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
C++
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40174
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40098
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40109
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40111
#include 4
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 977 ____47 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62& nbsp; độ phức tạp về thời gian: & nbsp; vì chúng tôi đang đi qua hai danh sách đầy đủ. Vì vậy, độ phức tạp về thời gian là O [M+N] trong đó M và N là độ dài của hai danh sách sẽ được hợp nhất. & NBSP;
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 69List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40002
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62Phương pháp 4 [đảo ngược danh sách]
Ý tưởng này bao gồm lần đầu tiên đảo ngược cả danh sách đã cho và sau khi đảo ngược, đi qua cả hai danh sách cho đến cuối và sau đó so sánh các nút của cả hai danh sách và chèn nút có giá trị lớn hơn ở đầu danh sách kết quả. Và theo cách này, chúng tôi sẽ nhận được danh sách kết quả theo thứ tự tăng lên.
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40011
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40013
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40015
Dưới đây là việc thực hiện giải pháp trên.
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40020
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40023
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40025
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40027
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40029
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 992 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 997#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40037
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40039
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 68#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40050
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40052
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40063
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40037
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40039
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40076
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40050
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40052
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40094
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40098
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40285
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40105
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40109
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40111
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40298
{ 8 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40300
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40120
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40122
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40125
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 #include 061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 #include 101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40134
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40136
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40138
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40140
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40142
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40144
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40146
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 48List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40150
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40153
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 48List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40157
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40160
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40162
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 48List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40166
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 371] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 #include 40List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Java
#include 42 #include 43
class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 903using22 class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9971] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 511] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 69using22
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40367
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40371
#include 58#include 73#include 4class3
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40378
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40380
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40382
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40018
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
using22
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40390
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40023
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40025
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40397
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40401
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40404
#include 58 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40406
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40411
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40413
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40415
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40426
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40428
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40404
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40413
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40415
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40454
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40426
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40428
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4086
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40094
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40098
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40481
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17#include 35#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40485
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40105
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40109
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40111
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40499
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40501
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40125
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 #include 061] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 60 #include 101] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40514
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40518
using38#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40522
using44#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40526
using50#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40530
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 853#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40534
using56#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40538
using62#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40542
using68#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40546
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40150
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40153
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40546
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40157
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40160
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40162
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40153
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 37List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
C#
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 #include 40Java
#include 42 #include 43
class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 903using22 class
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9941] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 01] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9971] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 69using22
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40367
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40371
#include 58#include 73#include 4class3
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40378
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40380
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40018
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40018
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
using22
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40390
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40023
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40025
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40397
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40401
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40404
#include 58 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40406
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4#include 5
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40411
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40413
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40415
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
#include 4using7
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40426
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40428
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 9
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40404
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40413
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40415
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40041
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40043
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40454
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40426
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40428
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40054
#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40056
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40009
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
using22
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40473
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 0 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40477
#include 581] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 311#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40700
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 17#include 35#include 4
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40485
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
using22
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40490
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 4 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40111
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 62____10
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40495
{ 8 { 91] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40499
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40501
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0class3 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40125
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 1 using22 1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 9 List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40730
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 621] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40514
#include 58List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4005
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40737
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40739
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40741
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40743
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40745
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40747
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40749
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40751
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40150
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40153
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40751
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40157
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40160
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40162
1] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40751
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40166
#include 351] Initialize result list as empty: head = NULL.
2] Let 'a' and 'b' be the heads of first and second list respectively.
3] Reverse both the lists.
4] While [a != NULL and b != NULL]
a] Find the larger of two [Current 'a' and 'b']
b] Insert the larger value of node at the front of result list.
c] Move ahead in the list of larger node.
5] If 'b' becomes NULL before 'a', insert all nodes of 'a'
into result list at the beginning.
6] If 'a' becomes NULL before 'b', insert all nodes of 'b'
into result list at the beginning. 0#include 37List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 4007
Output:
List A before merge: 5 10 15 40 List B before merge: 2 3 20 Merged Linked List is: 2 3 5 10 15 20 40
Độ phức tạp về thời gian: & nbsp; Vì chúng tôi đang đi qua hai danh sách đầy đủ. Vì vậy, độ phức tạp về thời gian là O [M+N] trong đó M và N là độ dài của hai danh sách sẽ được hợp nhất. & NBSP; Since we are traversing through the two lists fully. So, the time complexity is O[m+n] where m and n are the lengths of the two lists to be merged.
Phương pháp này được đóng góp bởi Mehul Mathur [Mathurmehul01]. & NBSP;Mehul Mathur[mathurmehul01].
Ý tưởng này tương tự như bài viết này.
Vui lòng tham khảo bài đăng dưới đây để triển khai đơn giản hơn: & nbsp; hợp nhất hai danh sách được sắp xếp [tại chỗ] Nguồn: //csl Library.stanford.edu/105/linkedlistproblems.pdflease Viết nhận xét Nếu bạn tìm thấy mã trên/thuật toán trên Những cách tốt hơn để giải quyết vấn đề tương tự.
Merge two sorted lists [in-place]
Source: //cslibrary.stanford.edu/105/LinkedListProblems.pdf
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.
Làm thế nào để bạn hợp nhất một danh sách được liên kết?
Thuật toán cho Sắp xếp hợp nhất Nếu: Danh sách chứa một hoặc ít phần tử hơn, trả về cùng một danh sách. Khác: Chia danh sách thành một nửa bằng cách sử dụng chức năng chia tách. Sắp xếp: Sắp xếp hai nửa của danh sách. Cuối cùng, hợp nhất các danh sách được sắp xếp.If: The list contains one or fewer elements, return the same list. Else: Divide the list into halves using the splitting function. Sort: Sort the two halves of the list. At the end, merge the sorted lists.
Làm thế nào để bạn hợp nhất hai danh sách trong Python?
SortedMerge [] sẽ trả về danh sách mới.Danh sách mới nên được thực hiện bằng cách ghép các nút của hai danh sách đầu tiên.Ví dụ: nếu danh sách được liên kết đầu tiên A là 5-> 10-> 15 và danh sách được liên kết khác B là 2-> 3-> 20, thì Sett3-> 5-> 10-> 15-> 20.. The new list should be made by splicing together the nodes of the first two lists. For example if the first linked list a is 5->10->15 and the other linked list b is 2->3->20, then SortedMerge[] should return a pointer to the head node of the merged list 2->3->5->10->15->20.
Thuật toán nào phù hợp nhất để hợp nhất hai danh sách được liên kết?
Phương pháp: Sử dụng đệ quy trong phương pháp trên, chúng tôi đã thử cách tiếp cận lặp bằng cách sử dụng các nút giả.Bây giờ chúng tôi sẽ thử kỹ thuật đệ quy để hợp nhất hai danh sách liên kết được sắp xếp.Có ít mã hơn so với cách tiếp cận lặp vì nó sử dụng ngăn xếp cuộc gọi để tự gọi để làm việc với các đối số được thông qua.Using Recursion
In the above method we tried the iterative approach using dummy nodes. Now we will try the recursion technique to merge two sorted LinkedLists. There is less code than with the iterative approach as it uses the call stack to call itself to work with passed arguments.
Làm thế nào để tôi kết hợp hai danh sách liên kết gấp đôi?
Cách tiếp cận: Sau đây là các bước:..
Nếu đầu1 == null, hãy trả lại đầu 2 ..
Nếu head2 == null, return head1 ..
Đặt Last1 và Last2 lần lượt là nút cuối cùng của hai danh sách.....
Nhận con trỏ đến nút sẽ là nút cuối cùng của danh sách cuối cùng.....
Cập nhật Last 1 ..