用C++，设有两条有序链表（即 data 域元素的关键字由前往后不断增大），试设计算法，将这两 条链表合并为一条新的有序链表，原链表不变。两条链表中 data 域关键字相同的元素只选 取一个存储到新的有序链表中，不同的元素都存储到新的有序链表中。 要求： ➢ 直接编写链表的友元函数完成该功能。 ➢ 链表的 data 域可存储用户自定义类对象。 ➢ 编写测试 main()函数测试线性表的正确性

这里提供一个链表类的实现，并在其中添加了一个静态的合并函数 Merge，可以将两个有序链表合并成一个新的有序链表。

#include <iostream>

using namespace std;

template <typename T>
class Node {
public:
    T data;
    Node<T>* next;

    Node(T data) : data(data), next(nullptr) {}
};

template <typename T>
class LinkedList {
private:
    Node<T>* head;
    int count;

public:
    LinkedList() : head(nullptr), count(0) {}
    ~LinkedList() {
        Node<T>* p = head;
        while (p != nullptr) {
            Node<T>* q = p;
            p = p->next;
            delete q;
        }
    }

    void insert(T data) {
        Node<T>* p = new Node<T>(data);
        p->next = head;
        head = p;
        count++;
    }

    void print() {
        Node<T>* p = head;
        while (p != nullptr) {
            cout << p->data << " ";
            p = p->next;
        }
        cout << endl;
    }

    int size() {
        return count;
    }

    Node<T>* getHead() {
        return head;
    }

    static LinkedList<T> Merge(LinkedList<T>& list1, LinkedList<T>& list2) {
        LinkedList<T> result;

        Node<T>* p = list1.getHead();
        Node<T>* q = list2.getHead();

        while (p != nullptr && q != nullptr) {
            if (p->data < q->data) {
                result.insert(p->data);
                p = p->next;
            } else if (p->data > q->data) {
                result.insert(q->data);
                q = q->next;
            } else {
                result.insert(p->data);
                p = p->next;
                q = q->next;
            }
        }

        while (p != nullptr) {
            result.insert(p->data);
            p = p->next;
        }

        while (q != nullptr) {
            result.insert(q->data);
            q = q->next;
        }

        return result;
    }
};

class Person {
public:
    string name;
    int age;

    Person(string name, int age) : name(name), age(age) {}

    bool operator<(const Person& other) const {
        return age < other.age;
    }

    bool operator>(const Person& other) const {
        return age > other.age;
    }

    bool operator==(const Person& other) const {
        return age == other.age;
    }

    friend ostream& operator<<(ostream& os, const Person& person) {
        os << person.name << "(" << person.age << ")";
        return os;
    }
};

int main() {
    LinkedList<int> list1;
    list1.insert(6);
    list1.insert(4);
    list1.insert(2);
    list1.insert(0);
    list1.print();

    LinkedList<int> list2;
    list2.insert(7);
    list2.insert(5);
    list2.insert(3);
    list2.insert(1);
    list2.print();

    LinkedList<int> result = LinkedList<int>::Merge(list1, list2);
    result.print();

    LinkedList<Person> people1;
    people1.insert(Person("Alice", 20));
    people1.insert(Person("Bob", 30));
    people1.insert(Person("Charlie", 40));
    people1.print();

    LinkedList<Person> people2;
    people2.insert(Person("David", 35));
    people2.insert(Person("Eva", 25));
    people2.insert(Person("Frank", 45));
    people2.print();

    LinkedList<Person> peopleResult = LinkedList<Person>::Merge(people1, people2);
    peopleResult.print();

    return 0;
}

上述代码中，我们首先定义了一个 Node 类，表示链表中的一个节点，其中包含了一个 data 成员变量和一个指向下一个节点的指针 next。

然后定义了一个 LinkedList 类，表示一个链表，其中包含了一个指向链表头节点的指针 head 和一个表示链表大小的 count。

在 LinkedList 类中，我们实现了以下方法：

- insert：向链表中插入一个元素。
- print：打印链表中的所有元素。
- size：返回链表的大小。
- getHead：返回链表头节点的指针。
- Merge：静态方法，用于将两个有序链表合并成一个新的有序链表。

在 Merge 方法中，我们首先获取了两个链表的头节点指针 p 和 q，然后利用 p 和 q 中的元素依次构建新的链表，并返回结果。

最后，我们在 main 函数中使用 LinkedList 类来创建两个链表，然后调用 Merge 方法将它们合并，最后打印结果。注意，我们在程序中还定义了一个 Person 类，用于演示链表中存储用户自定义类对象的情况。在 Person 类中，我们定义了三个比较运算符，分别用于比较两个 Person 对象的大小关系，以及一个输出运算符，用于打印 Person 对象。