Списки. Как создать одновременно 2 списка? Как из второго списка поместить элементы в первый?

#include <stdio.h>
#include <string>
#include <iostream>
#include <conio.h>
using namespace std;
using std::cout;
using std::cin;
using std::endl;
 
struct List {
    float info;
    List *pred, *next;
};
int k;
 
//функция создает новый элемент к и вставляет в список q
List *AddList(List *q, int k){
    List*p;
    p = new List;
    p->info = k;
    p->pred = q;
    p->next = q->next;
    p->next->pred = p;
    q->next = p;
    return p;
}
//функция создает двусвязный список со сторожами head,tail
void CreatList(List *&head, List *&tail) {
    List *q, *p;
    head = new List;
    tail = new List;
    head->next = tail;
    tail->pred = head;
    head->pred = tail->next = NULL;
    cout << "Вводите числа,для выхода введите 101" << endl;
    cin >> k;
    q = head;
    while (k != 101)//пока к !=101
    {
        q = AddList(q, k);
        cin >> k;
    }
    return;
};
 
//вывод списка на экран
void PrintList(List *head, List*tail){
    List *p = head->next;
    while (p != tail){
        cout << p->info << " ";
        p = p->next;
    }
    cout << endl;
    return;
};
//функция "вынимает" элемент из списка
void CutList(List *&p){
    List *a, *b;//указатели на соседей
    a = p->next;
    b = p->pred;
    a->pred = p->pred;
    b->next = p->next;
    return;
}
//функция меняет местами 2 элемента списка
void Swap(List *&p, List*&q){
    q->next = p->next;
    p->next = q->pred->next;
    p->pred = q->pred;
    q->pred = q->next->pred;
    p->next->pred = p;
    p->pred->next = p;
    q->next->pred = q;
    q->pred->next = q;
 
    return;
}
 
 
 
 
void main(){
    setlocale(LC_ALL, "Russian");
    List *head, *tail;
    List *s, *w;//сторожа
 
    CreatList(head, tail);
    cout << "исходный список" << endl;
    PrintList(head, tail);
    
    CreatList(s,w);  //вот я создала другой список. но что делать дальше, не знаю(
    cout << "2 список" << endl;
    PrintList(s, w);
 
    cout << "конечный список" << endl;
    PrintList(head, tail);
 
 
    system("pause");
    return;
}

#include <iostream>
 
using namespace std;
 
struct data_t
{
    int value;
    data_t() {}
    data_t(int value) : value(value) {}
    data_t(const data_t& d) : value(d.value) {}
};
 
struct node_t:public data_t
{
    node_t():
        next(nullptr), prev(nullptr) {}
    node_t(const data_t& d, node_t* n = nullptr, node_t* p = nullptr):
         data_t(d.value),next(n), prev(p) {}
    node_t* next;
    node_t* prev;
};
 
struct list_t
{
    node_t* m_head;
    node_t* m_last;
    list_t() : m_head(nullptr), m_last(nullptr) {}
    list_t(list_t&& l) : m_head(nullptr), m_last(nullptr) {
        std::swap(l.m_head, m_head);
        std::swap(l.m_last, m_last);
    }
    list_t& operator=(list_t&& l)  {
        std::swap(l.m_head, m_head);
        std::swap(l.m_last, m_last);
        return *this;
    }
    node_t* head()
    {
        return m_head;
    }
 
    /// добавление в начало
    inline void push_front(const data_t& data)
    {
        return paste_node(new node_t(data), nullptr);
    }
    /// добавление в конец списка
    inline void push_back(const data_t& data)
    {
        return paste_node(new node_t(data), m_last);
    }
    inline void reverse_print() const
    {
        return reverse_print_from(m_last);
    }
    inline void forward_print() const
    {
        return forward_print_from(m_head);
    }
 
    /// обменивает 2 элемента по индексам
    void swap_nodes(int index1, int index2)
    {
        if (index1 > index2)
        {
            int temp = index1;
            index1 = index2;
            index2 = temp;
        }
 
        if (index1 < 0 || index1 == index2)
            return;
 
        node_t* index1Node = nullptr;
        node_t* index2Node = nullptr;
 
        index1Node = get_by_idx(index1 ,m_head);
        if (index1Node == nullptr)
            return;
        index2Node = get_by_idx(index2 - index1, index1Node);
 
        if (index2Node == nullptr)
            return;
 
 
        node_t *n1p, *n1n;
        n1n = index1Node->next;
        n1p = index1Node->prev;
 
        cut_node(index1Node);
        paste_node(index1Node, index2Node);
        if(n1n != index2Node) {
            cut_node(index2Node);
            paste_node(index2Node, n1p);
        }
 
    }
    /// ищет максимальный элемент
    /// список должен быть не пуст
    data_t find_max() {
        data_t  t;
        node_t* h = m_head;
        t.value = h->value;
        while(h) {
            if(t.value < h->value)
                t.value = h->value;
            h = h->next;
        }
        return t;
    }
    /// вставляет копию списка l после элементов со значением m
    list_t& insert(const list_t& l, const data_t& m) {
        auto n = m_head;
        while(n) {
            n = find_from(n, m);
            if(n)
                n = insert_copy(l, n);
        }
        return *this;
    }
private:
    /// ищет d начиная со звена n
    node_t* find_from(node_t* n, const data_t& d) const {
        while(n) {
            if(n->value == d.value)
                break;
            n = n->next;
        }
        return n;
    }
    node_t* insert_copy(const list_t& l, node_t* n) {
        node_t* h;
        h = l.m_head;
        while(h) {
            paste_node(new node_t(h->value),n);
            n = n->next;
            h = h->next;
        }
        return n;
    }
    /// печатает список от указанного звена к началу
    void reverse_print_from(const node_t* tmp) const
    {
        while (tmp != nullptr)
        {
            cout << tmp->value << " ";
            tmp = tmp->prev;
        }
        cout << endl;
    }
    /// печатает от указанного звена до конца списка
    void forward_print_from(const node_t* tmp) const
    {
        while (tmp != nullptr)
        {
            cout << tmp->value << " ";
            tmp = tmp->next;
        }
        cout << endl;
    }
    /// вырезает указанное звено из списка
    void cut_node(node_t* n) {
        if(n == m_head) m_head = m_head->next;
        else if(n->prev) {
            n->prev->next = n->next;
        }
        if(n == m_last) m_last = m_last->prev;
        else if(n->next) {
            n->next->prev = n->prev;
        }
        n->next = nullptr;
        n->prev = nullptr;
    }
    /// вставляет звено n после x. при x == nullptr вставляет в начало
    void paste_node(node_t* n, node_t* x) {
        if (x == nullptr) {
            n->next = m_head;
            if(!m_head) {
                m_head = m_last = n;
            }
            else {
                m_head->prev = n;
                m_head = n;
            }
        }
        else {
            n->next = x->next;
            n->prev = x;
            if (x->next) x->next->prev = n;
            x->next = n;
            if (x == m_last) m_last = n;
        }
    }
    /// поиск звена по смещению от first
    static node_t* get_by_idx(int idx,
                            node_t* first) {
        int index = 0;
        while (first) {
            if (index == idx) break;
            first = first->next;
            index++;
        }
        return first;
    }
};
 
 
int main()
{
    list_t l1, l2;
 
    ///
    ///TODO: ввод элементов сделайте самостоятельно
    ///
 
    l1.insert(l2, l1.find_max()) // код вне main позволяет
                                 // свести задачу к этой строчке
            .forward_print();
    return 0;
}