Combinación de dos secuencias de listas enlazadas ordenadas (20 puntos)

Dadas dos secuencias de listas enlazadas no descendentes S1 y S2, la función de diseño construye una nueva lista enlazada no descendente S3 después de que se fusionen S1 y S2.

Formato de entrada: La
entrada se divide en dos líneas. Cada línea da una secuencia no descendente compuesta por varios números enteros positivos. Utilice −1 para indicar el final de la secuencia (−1 no pertenece a esta secuencia). Los números están separados por espacios.

Formato de
salida : muestra la nueva lista vinculada no descendente combinada en una línea. Los números están separados por espacios y no puede haber espacios adicionales al final; si la nueva lista vinculada está vacía, se genera NULL.

Muestra de entrada:

1 3 5 -1
2 4 6 8 10 -1

Salida de muestra:

1 2 3 4 5 6 8 10

Idea de la pregunta: la idea de establecer una lista enlazada de forma rutinaria. Por supuesto, este problema también se puede resolver utilizando contenedores vectoriales, que es más rápido. Escribiré otra publicación de blog cuando tenga tiempo en el futuro.

#include<iostream>
using namespace std;

typedef struct node {
    
    
	int data;
	struct node* next;
}List;

List* creat();
List* sort(List* L1, List* L2);
void print(List* L);
void Delete(List* L);
int main()
{
    
    
	List* L1, * L2, *L3;

	L1 = creat();
	L2 = creat();
	L3 = sort(L1, L2);
	print(L3);

	Delete(L3);
	return 0;
}
List* creat()
{
    
    
	List* head, * p, * rear;
	head = new List;
	head->next = NULL;
	rear = head;


	p = new List;
	p->next = NULL;
	cin >> p->data;
	while (p->data != -1)
	{
    
    
		rear->next = p;
		rear = p;


		p = new List;
		p->next = NULL;
		cin >> p->data;
	}

	return head;
}
void print(List* L)
{
    
    
	List* p;
	p = L->next;
	if (p)
	{
    
    
		cout << p->data;
		p = p->next;
		while (p)
		{
    
    
			cout << " " << p->data;
			p = p->next;
		}
	}
	else
		cout << "NULL";
	
	cout << endl;
}
void Delete(List* L)
{
    
    
	List* p, *q;
	p = L;
	while (p)
	{
    
    
		q = p->next;
		delete p;
		p = q;
	}

	
}
List* sort(List* L1, List* L2)
{
    
    
	List* L3, * pa, * pb, * pc;
	L3 = new List;
	pa = L1->next;
	pb = L2->next;
	pc = L3;
	while (pa && pb)
	{
    
    
		if (pa->data < pb->data)
		{
    
    
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else
		{
    
    
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	
	return L3;
}