如此简单，我怎么被干懵了

使用标准模板库解题

#include <iostream>
#include <iomanip>
#include <list>
using namespace std;
void print(list <int>& ls)
{
    list<int>::iterator it;
    for(it=ls.begin();it!=ls.end();it++)
        cout<< setw(4) << *it;
    cout << endl;
}
int main()
{
    int a[4] = {2,4,6,8};
    int b[4] = {1,3,5,7};
    list <int> l1(a,a+4);
    list <int> l2(b,b+4);
    list <int> l3(0);
    l3.merge(l1);
    l3.merge(l2);
    l3.sort();
    for(auto element : l3) cout << element << " ";

    //print(l3);
/*
    for(auto ptr = l3.begin();ptr!=l3.end();ptr++)
        cout << *ptr << "->";
    cout << "nullptr" << endl;
*/
    return 0;
}

面向过程解题

#include <iostream>
#include <string>
using namespace std;

// [2,4,6,8];
// [1,3,5,7];

struct ListNode {
    int val;
    ListNode *next;

    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}


    ~ListNode()
    {
        cout << "析构" << val << endl;
        if (next != nullptr)
            delete next;
        next = nullptr;
    };
};

ListNode* merge_two_sorted_list(ListNode* l1,ListNode* l2){

    ListNode *tempList = nullptr;
    while(l1 != nullptr )
            {
                tempList = new ListNode(l1->val, tempList);
                l1 = l1->next;
            }
    while(l2 != nullptr )
        {
            tempList = new ListNode(l2->val, tempList);
            l2 = l2->next;
        }
    l1 = nullptr;//指针用完指空
    l2 = nullptr;

    if(tempList != nullptr)
    {
        ListNode* sampleValptr = tempList->next;
        ListNode* compareValptr = tempList;
        while(sampleValptr != nullptr)
        {
            int tempValue = 0;
            while(compareValptr != sampleValptr)
                {
                    if(compareValptr->val > sampleValptr->val)
                    {
                        tempValue = compareValptr->val;
                        compareValptr->val = sampleValptr->val;
                        sampleValptr->val = tempValue;
                    }
                    compareValptr = compareValptr->next;    //取下一个比较值
                }
            compareValptr = tempList;     //重置比较比较值指针
            sampleValptr = sampleValptr->next;   //取下一个采样值
         }

        compareValptr =nullptr;//指针用完指空
        sampleValptr = nullptr;
    }

    return tempList;
}

int main()
{
    int a[4] = {2,4,6,8};
    int b[4] = {1,3,5,7};

    ListNode *List1 = nullptr;
    ListNode *List2 = nullptr;

    int i = 0;
    while(i < 4)
    {
        List1 = new ListNode(a[i], List1);
        List2 = new ListNode(b[i], List2);
        i = i+1;
    }

    ListNode* List3 = merge_two_sorted_list(List1,List2);
    ListNode* accessNode = List3; //访问List3用的指针

    while(accessNode != nullptr)
    {
        cout<< accessNode->val << " -> ";
        accessNode = accessNode->next;
    }
    cout<< "nullptr" << endl;


    accessNode = nullptr;

    delete List1;
    delete List2;
    delete List3;

    List1 = nullptr;
    List2 = nullptr;
    List3 = nullptr;

    return 0;

}

面向对象解题

#include <iostream>
using namespace std;

class ListNode
{
private:
    int nodeData;   //节点数据
    ListNode* nextNodePointer;  //指针指向下一个节点的首地址

public:
    ListNode(int data = 0, ListNode* next = nullptr) : nodeData(data), nextNodePointer(next){};
    ListNode(const ListNode& node) : nodeData(node.nodeData), nextNodePointer(node.nextNodePointer){}

    ListNode* CreateNode(int data)
    {
        nextNodePointer = new ListNode(data);
        if (nextNodePointer != nullptr)    //如果不为空，则结点开辟空间成功
            nextNodePointer->nextNodePointer = nullptr;
        else    //如果是空，则结点开辟空间失败了
            cout << "申请节点内存失败" << endl;
        return nextNodePointer; //无论开辟成功或则失败,在列表中插入中判断
    }

    /*  //不赞成调用递归析构，如果链表过大则会导致内存开销过大
    ~ListNode()
    {
        cout << "析构" << nodeData << endl;
        if (nextNodePointer != nullptr)
            delete nextNodePointer;
        nextNodePointer = nullptr;
    };*/

    ~ListNode()
    {
        while (nextNodePointer != nullptr)//因为lastNodePointerNode->nextNodePointer==nullptr，所以进不来
        {
            ListNode* prelastNodePointerNode = this;//只有一个节点时，prelastNodePointerNode->nextNodePointer= nullptr，即要把头结点的下一个元素置空
            ListNode* lastNodePointerNode = prelastNodePointerNode->nextNodePointer;

            while (lastNodePointerNode->nextNodePointer != nullptr) {//如果一个节点的下一个节点是空，那他就是最后一个节点
                prelastNodePointerNode = lastNodePointerNode;
                lastNodePointerNode = lastNodePointerNode->nextNodePointer;//让lastNodePointerNode等于下一个lastNodePointerNode
            }
            cout << "    析构节点:" << lastNodePointerNode->nodeData << endl;
            prelastNodePointerNode->nextNodePointer = nullptr;//将上一个节点的指针置空，代表这是最后一个数据
            delete lastNodePointerNode;//删除最后一个节点
            lastNodePointerNode = nullptr;
        }
    };

    friend class List;//链表要访问设置next指针，申请为友元类
};

class List
{
private:
    ListNode* headNodePointer;
    ListNode* lastNodePointer;

public:
    //构造初始化链表
    List(int initialListSize = 0)//initialListSize是初始化给定的链表长度
    {
        headNodePointer = lastNodePointer = new ListNode(0);//生成头节点,头结点包含链表长度数据
        if (headNodePointer != nullptr)
        {
            initialListSize = initialListSize > 0 ? initialListSize : 0;//如果用户指定链表长度为负数,那就直接默认长度是0
            while (initialListSize > 0)
            {
                bool successToInsertNode = ValueInsert(initialListSize);//判断节点有没有插入成功
                if (successToInsertNode == false)
                {
                    cout << "创建节点阶段异常，但是成功创建" << headNodePointer->nodeData << "个节点，请尝试插入操作" << endl;
                    break;
                }
                initialListSize = initialListSize - 1;
            }
            cout << "初始化完成，列表包含" << headNodePointer->nodeData << "个节点！" << endl;
        }
        else
        {
            cout << "生成头节点异常，已创建终止列表" << endl;
        }
    }

    List(const List& list)  //做深拷贝构造
    {
        headNodePointer = lastNodePointer = new ListNode(*list.headNodePointer);  //生成头节点,头结点包含链表长度数据

        if (headNodePointer != nullptr) //判断头节点是否成功生成
        {
            while(lastNodePointer->nextNodePointer != nullptr)
            {
                lastNodePointer->nextNodePointer =  new ListNode(*lastNodePointer->nextNodePointer);;
                if (lastNodePointer->nextNodePointer != nullptr)    //拷贝构造节点成功
                {
                    lastNodePointer = lastNodePointer->nextNodePointer;
                }
                else     //拷贝构造节点失败
                {
                    cout << "拷贝构造节点失败，已创建终止列表" << endl;
                };
            }
            cout << "初始化完成，列表包含" << headNodePointer->nodeData << "个节点！" << endl;
        }
        else
        {
            cout << "生成头节点异常，已创建终止列表" << endl;
        }
    }

    //向链表中插入元素
    bool ValueInsert(int data = 0)
    {
        lastNodePointer->nextNodePointer = lastNodePointer->CreateNode(data);
        if (lastNodePointer->nextNodePointer != nullptr)//判断节点有没有申请成功
        {
            headNodePointer->nodeData++;
            lastNodePointer = lastNodePointer->nextNodePointer;
            return true;
        }
        else
        {
            cout << "节点插入失败" << endl;
            return false;
        }

    }

    //遍历链表信息
    void Show()
    {
        cout << "遍历链表信息" << headNodePointer->nodeData << "元素：";
        ListNode* forward = headNodePointer;
        while (forward->nextNodePointer != nullptr) //如果不是最后一个元素
        {
            forward = forward->nextNodePointer; //切换下一个元素
            cout << forward->nodeData << "->";
        }
        cout << "nullptr" << endl;
    }

    //级联链表
    void Concatenate(const List& list){
        if(list.headNodePointer->nextNodePointer != nullptr)
        {
            ListNode* tempNode = list.headNodePointer->nextNodePointer;
            while(tempNode != list.lastNodePointer->nextNodePointer){
                lastNodePointer->nextNodePointer =  new ListNode(*tempNode);
                if (lastNodePointer->nextNodePointer != nullptr)    //分配节点成功
                {
                    lastNodePointer = lastNodePointer->nextNodePointer;
                    tempNode=tempNode->nextNodePointer;
                    headNodePointer->nodeData++;
                }
                else
                {
                    cout << "拷贝构造节点失败，已终止复制列表" << endl;
                    break;
                }
            }
            cout << "级联链表完成，当前链表包含" << headNodePointer->nodeData << "个节点！" << endl;
        }
        else
        {
            cout << "空表,无需级联" <<endl;
        }
    }

    //链表排序
    void SelfSort()
    {
        int tempValue = 0;
        ListNode* sampleValuePointer = headNodePointer->nextNodePointer ;
        ListNode* compareValuePointer = headNodePointer->nextNodePointer;
        while (sampleValuePointer != lastNodePointer->nextNodePointer)  //链表中只有一个节点,直接不用比较了
        {
            while(compareValuePointer != sampleValuePointer)
            {
                if(compareValuePointer->nodeData > sampleValuePointer->nodeData)
                {
                    tempValue = compareValuePointer->nodeData;
                    compareValuePointer->nodeData = sampleValuePointer->nodeData;
                    sampleValuePointer->nodeData = tempValue;
                }
                compareValuePointer = compareValuePointer->nextNodePointer;//取下一个比较值
            }

            compareValuePointer = headNodePointer->nextNodePointer;     //重置比较比较值指针
            sampleValuePointer = sampleValuePointer->nextNodePointer;   //取下一个采样值
        };

    }

    //析构链表
    ~List()
    {
        cout << "析构链表开始" << endl;
        if (headNodePointer != nullptr)
            delete headNodePointer;//删除头结点，会调用节点的析构函数，调用节点的析构函数，会删除其他节点
        cout << "析构整个链表结束" << endl;
        headNodePointer = lastNodePointer = nullptr;
    }
};


int main()
{
    List l1(0);
    l1.ValueInsert(2);
    l1.ValueInsert(6);
    l1.ValueInsert(4);
    l1.ValueInsert(8);
    l1.Show();

    List l2(0);
    l2.ValueInsert(1);
    l2.ValueInsert(5);
    l2.ValueInsert(3);
    l2.ValueInsert(7);
    l2.Show();


    List l3(l1);
    l3.Concatenate(l2);
    l3.SelfSort();
    l3.Show();

}