#include <iostream>

template <class T>
class Node {
public:
	T value;
	Node<T>* next;
	Node<T>* prev;

	// constructor
	Node(T val) : value(val), next(nullptr), prev(nullptr) {}
};

// function to merge two sorted doubly linked lists
// this function returns a pointer pointing to the head node of the merged list.
template <class T>
Node<T>* mergeLists(Node<T>* head_A, Node<T>* head_B) {
    // If one list is empty, return the other
    if (!head_A) return head_B;
    if (!head_B) return head_A;

    // Decide the new head by comparing the first elements
    Node<T>* head = nullptr;
    Node<T>* tail = nullptr;

    // Pick whichever head is smaller as the new head
    if (head_A->value < head_B->value) {
        head = head_A;
        head_A = head_A->next;
    } else {
        head = head_B;
        head_B = head_B->next;
    }
    // At this point, 'head' is the first node of the merged list
    head->prev = nullptr; // new head has no previous
    tail = head;

    // Continue merging while both lists have nodes
    while (head_A && head_B) {
        if (head_A->value < head_B->value) {
            tail->next = head_A;
            head_A->prev = tail;
            tail = tail->next;
            head_A = head_A->next;
        } else {
            tail->next = head_B;
            head_B->prev = tail;
            tail = tail->next;
            head_B = head_B->next;
        }
    }

    // Append any remaining nodes from A or B
    if (head_A) {
        tail->next = head_A;
        head_A->prev = tail;
    } else if (head_B) {
        tail->next = head_B;
        head_B->prev = tail;
    }

    return head;
}

int main() {
	// create 5 nodes and link them to form a linked list, this is linked list A.
	Node<int>* head_A = new Node<int>(1);
	Node<int>* second_A = new Node<int>(3);
	Node<int>* third_A = new Node<int>(5);
	Node<int>* fourth_A = new Node<int>(7);
	Node<int>* fifth_A = new Node<int>(9);

	// link the nodes
	head_A->next = second_A;
	second_A->prev = head_A;
	second_A->next = third_A;
	third_A->prev = second_A;
	third_A->next = fourth_A;
	fourth_A->prev = third_A;
	fourth_A->next = fifth_A;
	fifth_A->prev = fourth_A;

	// traverse linked list A and print the values
	Node<int>* current = head_A;
	while (current != nullptr) {
		std::cout << current->value << " ";
		current = current->next;
	}
	std::cout << std::endl;

	// create 5 nodes and link them to form a linked list, this is linked list B.
	Node<int>* head_B = new Node<int>(2);
	Node<int>* second_B = new Node<int>(4);
	Node<int>* third_B = new Node<int>(6);
	Node<int>* fourth_B = new Node<int>(8);
	Node<int>* fifth_B = new Node<int>(10);

	// link the nodes
	head_B->next = second_B;
	second_B->prev = head_B;
	second_B->next = third_B;
	third_B->prev = second_B;
	third_B->next = fourth_B;
	fourth_B->prev = third_B;
	fourth_B->next = fifth_B;
	fifth_B->prev = fourth_B;

	// traverse linked list B and print the values
	current = head_B;
	while (current != nullptr) {
		std::cout << current->value << " ";
		current = current->next;
	}
	std::cout << std::endl;

	Node<int>* head_C;
	Node<int>* tail_C;
	head_C = mergeLists(head_A, head_B);

	// traverse linked list C and print the values
	current = head_C;
	while (current != nullptr) {
		std::cout << current->value << " ";
		// keep tracking current and when current reaches nullptr, tail_C will be the tail node.
		tail_C = current;
		current = current->next;
	}
	std::cout << std::endl;

	// traverse linked list C backwards and print the values
	current = tail_C;
	while (current != nullptr) {
		std::cout << current->value << " ";
		current = current->prev;
	}
	std::cout << std::endl;

	return 0;
}