Dadas dos listas enlazadas, cree listas de unión e intersección que contengan la unión y la intersección de los elementos presentes en las listas dadas. El orden de los elementos en las listas de salida no importa.
Ejemplo:
Input: List1: 10->15->4->20 List2: 8->4->2->10 Output: Intersection List: 4->10 Union List: 2->8->20->4->15->10
Método 1 (Simple):
Los siguientes son algoritmos simples para obtener listas de unión e intersección respectivamente.
1. Intersección (lista1, lista2):
Inicialice la lista de resultados como NULL. Recorra list1 y busque cada elemento en list2, si el elemento está presente en list2, luego agregue el elemento al resultado.
2. Unión (lista1, lista2):
inicializa la lista de resultados como NULL. Recorra list1 y agregue todos sus elementos al resultado.
poligonal list2. Si un elemento de list2 ya está presente en el resultado, no lo inserte en el resultado; de lo contrario, insértelo.
Este método asume que no hay duplicados en las listas dadas.
Gracias a Shekhu por sugerir este método. Las siguientes son implementaciones C y Java de este método.
C++
// C++ program to find union
// and intersection of two unsorted
// linked lists
#include <iostream>
using namespace std;
// Link list node
struct Node
{
int data;
struct Node* next;
};
/* A utility function to insert a
node at the beginning ofa linked list*/
void push(struct Node** head_ref,
int new_data);
/* A utility function to check if
given data is present in a list */
bool isPresent(struct Node* head,
int data);
/* Function to get union of two
linked lists head1 and head2 */
struct Node* getUnion(struct Node* head1,
struct Node* head2)
{
struct Node* result = NULL;
struct Node *t1 = head1, *t2 = head2;
// Insert all elements of
// list1 to the result list
while (t1 != NULL)
{
push(&result, t1->data);
t1 = t1->next;
}
// Insert those elements of list2
// which are not present in result list
while (t2 != NULL)
{
if (!isPresent(result, t2->data))
push(&result, t2->data);
t2 = t2->next;
}
return result;
}
/* Function to get intersection of
two linked lists head1 and head2 */
struct Node* getIntersection(struct Node* head1,
struct Node* head2)
{
struct Node* result = NULL;
struct Node* t1 = head1;
// Traverse list1 and search each element
// of it in list2. If the element is present
// in list 2, then insert the element to result
while (t1 != NULL)
{
if (isPresent(head2, t1->data))
push(&result, t1->data);
t1 = t1->next;
}
return result;
}
/* A utility function to insert a
node at the beginning of a linked list*/
void push(struct Node** head_ref,
int new_data)
{
// Allocate node
struct Node* new_node =
(struct Node*)malloc(
sizeof(struct Node));
// Put in the data
new_node->data = new_data;
/* Link the old list off the
new node */
new_node->next = (*head_ref);
/* Move the head to point to the
new node */
(*head_ref) = new_node;
}
/* A utility function to print a
linked list*/
void printList(struct Node* node)
{
while (node != NULL)
{
cout << " " << node->data;
node = node->next;
}
}
/* A utility function that returns true
if data is present in linked list
else return false */
bool isPresent(struct Node* head,
int data)
{
struct Node* t = head;
while (t != NULL)
{
if (t->data == data)
return 1;
t = t->next;
}
return 0;
}
// Driver code
int main()
{
// Start with the empty list
struct Node* head1 = NULL;
struct Node* head2 = NULL;
struct Node* intersection = NULL;
struct Node* unin = NULL;
// Create a linked lists 10->15->5->20
push(&head1, 20);
push(&head1, 4);
push(&head1, 15);
push(&head1, 10);
// Create a linked lists 8->4->2->10
push(&head2, 10);
push(&head2, 2);
push(&head2, 4);
push(&head2, 8);
intersection =
getIntersection(head1, head2);
unin = getUnion(head1, head2);
cout << "First list is " << endl;
printList(head1);
cout << "Second list is " << endl;
printList(head2);
cout << "Intersection list is " << endl;
printList(intersection);
cout << "Union list is " << endl;
printList(unin);
return 0;
}
// This code is contributed by shivanisingh2110
Producción
First list is 10 15 4 20 Second list is 8 4 2 10 Intersection list is 4 10 Union list is 2 8 20 4 15 10
Análisis de Complejidad:
- Complejidad temporal: O(m*n).
Aquí ‘m’ y ‘n’ son el número de elementos presentes en la primera y segunda lista respectivamente.
Para unión: para cada elemento en la lista-2, verificamos si ese elemento ya está presente en la lista resultante hecha usando la lista-1.
Para intersección: para cada elemento en la lista-1, verificamos si ese elemento también está presente en la lista-2. - Espacio Auxiliar: O(1).
No se utiliza ninguna estructura de datos para almacenar valores.
Método 2 (Usar Merge Sort):
En este método, los algoritmos para Unión e Intersección son muy similares. Primero, ordenamos las listas dadas, luego recorremos las listas ordenadas para obtener la unión y la intersección.
Los siguientes son los pasos a seguir para obtener listas de unión e intersección.
- Ordene la primera Lista Vinculada utilizando la ordenación por combinación. Este paso toma tiempo O(mLogm). Consulte esta publicación para obtener detalles de este paso.
- Ordene la segunda lista enlazada utilizando la ordenación por combinación. Este paso toma tiempo O(nLogn). Consulte esta publicación para obtener detalles de este paso.
- Escanea linealmente ambas listas ordenadas para obtener la unión y la intersección. Este paso toma O(m + n) tiempo. Este paso se puede implementar usando el mismo algoritmo que el algoritmo de arreglos ordenados discutido aquí .
La complejidad temporal de este método es O(mLogm + nLogn), que es mejor que la complejidad temporal del método 1.
Consulte el artículo completo sobre Unión e intersección de dos listas vinculadas para obtener más detalles.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA