3
3
1 2 4
3
1 3 4
0

0

3
1 3 5
1
2

1 1 2 3 4 4

1 2 3

import sys

# 定义链表节点
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 合并两个有序链表
def merge_two_lists(l1, l2):
    dummy = ListNode()  # 创建虚拟头节点
    current = dummy  # 当前指针

    # 遍历两个链表
    while l1 and l2:
        if l1.val < l2.val:
            current.next = l1  # 选择较小节点
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next  # 移动指针
    
    # 连接剩余链表
    current.next = l1 if l1 else l2
    return dummy.next

# 构造链表
def build_linked_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    current = head
    for val in values[1:]:
        current.next = ListNode(val)
        current = current.next
    return head

# 输出链表（空格分隔）
def print_linked_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" ".join(result))

# 读取输入并处理
def main():
    t = int(sys.stdin.readline().strip())  # 读取测试用例数量
    for _ in range(t):
        n = int(sys.stdin.readline().strip())  # 读取第一个链表大小
        l1 = list(map(int, sys.stdin.readline().split())) if n else []
        m = int(sys.stdin.readline().strip())  # 读取第二个链表大小
        l2 = list(map(int, sys.stdin.readline().split())) if m else []

        l1_head = build_linked_list(l1)  # 构造链表
        l2_head = build_linked_list(l2)
        merged_head = merge_two_lists(l1_head, l2_head)  # 合并链表
        print_linked_list(merged_head)  # 输出结果

if __name__ == "__main__":
    main()

import java.util.*;

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

public class Main {
    // 合并两个有序链表
    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0); // 创建虚拟头节点
        ListNode current = dummy; // 当前指针

        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                current.next = l1; // 选择较小节点
                l1 = l1.next;
            } else {
                current.next = l2;
                l2 = l2.next;
            }
            current = current.next; // 移动指针
        }

        current.next = (l1 != null) ? l1 : l2; // 连接剩余链表
        return dummy.next;
    }

    // 构造链表
    public static ListNode buildLinkedList(int[] values) {
        if (values.length == 0) return null;
        ListNode head = new ListNode(values[0]);
        ListNode current = head;
        for (int i = 1; i < values.length; i++) {
            current.next = new ListNode(values[i]);
            current = current.next;
        }
        return head;
    }

    // 输出链表（空格分隔）
    public static void printLinkedList(ListNode head) {
        StringBuilder sb = new StringBuilder();
        while (head != null) {
            sb.append(head.val).append(" ");
            head = head.next;
        }
        System.out.println(sb.toString().trim());
    }

    // 读取输入并处理
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt(); // 读取测试用例数量
        while (t-- > 0) {
            int n = sc.nextInt(); // 读取第一个链表大小
            int[] l1 = new int[n];
            for (int i = 0; i < n; i++) l1[i] = sc.nextInt();

            int m = sc.nextInt(); // 读取第二个链表大小
            int[] l2 = new int[m];
            for (int i = 0; i < m; i++) l2[i] = sc.nextInt();

            ListNode l1Head = buildLinkedList(l1); // 构造链表
            ListNode l2Head = buildLinkedList(l2);
            ListNode mergedHead = mergeTwoLists(l1Head, l2Head); // 合并链表
            printLinkedList(mergedHead); // 输出结果
        }
        sc.close();
    }
}

#include <iostream>
#include <vector>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int val) : val(val), next(nullptr) {}
};

// 合并两个有序链表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(0); // 创建虚拟头节点
    ListNode* current = &dummy; // 当前指针

    while (l1 && l2) {
        if (l1->val < l2->val) {
            current->next = l1; // 选择较小节点
            l1 = l1->next;
        } else {
            current->next = l2;
            l2 = l2->next;
        }
        current = current->next; // 移动指针
    }

    current->next = l1 ? l1 : l2; // 连接剩余链表
    return dummy.next;
}

// 构造链表
ListNode* buildLinkedList(const vector<int>& values) {
    if (values.empty()) return nullptr;
    ListNode* head = new ListNode(values[0]);
    ListNode* current = head;
    for (size_t i = 1; i < values.size(); i++) {
        current->next = new ListNode(values[i]);
        current = current->next;
    }
    return head;
}

// 输出链表（空格分隔）
void printLinkedList(ListNode* head) {
    bool first = true;
    while (head) {
        if (!first) cout << " ";
        cout << head->val;
        head = head->next;
        first = false;
    }
    cout << "\n";
}

int main() {
    int t;
    cin >> t; // 读取测试用例数量
    while (t--) {
        int n;
        cin >> n; // 读取第一个链表大小
        vector<int> l1(n);
        for (int i = 0; i < n; i++) cin >> l1[i];

        int m;
        cin >> m; // 读取第二个链表大小
        vector<int> l2(m);
        for (int i = 0; i < m; i++) cin >> l2[i];

        ListNode* l1Head = buildLinkedList(l1); // 构造链表
        ListNode* l2Head = buildLinkedList(l2);
        ListNode* mergedHead = mergeTwoLists(l1Head, l2Head); // 合并链表
        printLinkedList(mergedHead); // 输出结果
    }
    return 0;
}