Combinaison de deux séquences de listes chaînées ordonnées (20 points)

Étant donné deux séquences de listes liées non descendantes S1 et S2, la fonction de conception construit une nouvelle liste liée non descendante S3 après la fusion de S1 et S2.

Format d'entrée: L'
entrée est divisée en deux lignes. Chaque ligne donne une séquence non descendante composée de plusieurs entiers positifs. Utilisez −1 pour indiquer la fin de la séquence (−1 n'appartient pas à cette séquence). Les nombres sont séparés par des espaces.

Format de
sortie : affiche la nouvelle liste chaînée non descendante fusionnée sur une ligne. Les nombres sont séparés par des espaces et il ne peut y avoir aucun espace supplémentaire à la fin; si la nouvelle liste chaînée est vide, NULL est affiché.

Échantillon d'entrée:

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

Exemple de sortie:

1 2 3 4 5 6 8 10

Idée de question: l'idée d'établir une liste chaînée régulièrement. Bien entendu, ce problème peut également être résolu à l'aide de conteneurs vectoriels, ce qui est plus rapide. J'écrirai un autre article de blog quand j'aurai le temps dans le futur.

#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;
}