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 <stdbool.h> #include <stdio.h> #include <stdlib.h> // 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) { printf("%d ", 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* intersecn = 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 lits 8->4->2->10 */ push(&head2, 10); push(&head2, 2); push(&head2, 4); push(&head2, 8); intersecn = getIntersection(head1, head2); unin = getUnion(head1, head2); printf("First list is "); printList(head1); printf("Second list is "); printList(head2); printf("Intersection list is "); printList(intersecn); printf("Union list is "); printList(unin); return 0; }
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 fusió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