Finding the set and intersection of linked lists

Given 2 linked lists, the set (linked list) and intersection (linked list) of the 2 linked lists are obtained. The elements in the set (linked list) and intersection (linked list) are not required to be ordered.

For example, enter:

List1:10->15->4->20

List2:8->4->2->10

Output:

Intersection (linked list): 4->10

Set (linked list): 2->8->20->4->15->10

Method One (simple, intuitive method):

Here is a simple algorithm that gets the set and intersection of 2 lists.

Intersection (LIST1,LIST2): Initialize the result of the list is empty, traverse the list 1, in the list 2 to find each of its elements, if the linked List 2 also has this element, then insert the element into the result list.

Union (LIST1,LIST2): The initialization result list is empty, and all elements in the list 1 are inserted into the result list. Iterate through the chain List 2, if the result list does not have the element, then insert, otherwise skip the element.

2. #include <stdio.h>
4. #include <stdlib.h>
8. /*link List node*/
10. struct node
12. {
14. int data;
16. struct node* next;
18. };
22. /* A utility function to insert a node at the begining of a linked list */
24. void push (struct node **head_ref, int new_data);
28. /* A utility function to CHEC if given data are present in a list */
30. BOOL IsPresent (struct node *head, int data);
34. /* Function to get union of linked lists Head1 and head2*/
36. struct node *getunion (struct node *head1, struct node *head2)
38. {
40. struct node *result = NULL;
42. struct Node *t1 = head1, *t2 = head2;
46. //insert all elements of list1 to result list
48. While (t1! = NULL)
50. {
52. Push (&result, t1->data);
54. T1 = t1->next;
56. }
60. //insert Those elements of list2 which is not present in result list
62. While (t2! = NULL)
64. {
66. if (!ispresent (result, t2->data))
68. Push (&result, t2->data);
70. T2 = t2->next;
72. }
76. return result;
78. }
82. /* Function to get intersection of linked lists Head1 and head2 */
84. struct node *getintersection (struct node *head1, struct node *head2)
86. {
88. struct node *result = NULL;
90. struct node *t1 = head1;
94. //traverse List1 and search each element of the it in List2. If the element
96. //is present in List2, then insert the element to result
98. While (t1! = NULL)
100. {
102. if (isPresent (head2, t1->data))
104. Push (&result, t1->data);
106. T1 = t1->next;
108. }
112. return result;
114. }
118. /* A utility function to insert a node at the begining of a linked list */
120. void push (struct node**head_ref, int new_data)
122. {
124. /*allocate node*/
126. struct node* new_node = (struct node*) malloc (sizeof (struct node));
130. / * Put in the data * /
132. New_node->data = New_data;
136. /*link The old list off the new node*/
138. New_node->next = (*head_ref);
142. / * Move the head to point to the new node*/
144. (*head_ref) = New_node;
146. }
150. /*a utility function FTO print A linked list*/
152. void Printlist (struct node *node)
154. {
156. While (node! = NULL)
158. {
160. printf ("%d", node->data);
162. node = node->next;
164. }
166. }
170. /*a utility function that returns TRUE if the data is present in
172. Linked list Else Reurn false */
174. BOOL IsPresent (struct node *head, int data)
176. {
178. struct Node *t = head;
180. While (t! = NULL)
182. {
184. if (t->data = = data)
186. return 1;
188. t = t->next;
190. }
192. return 0;
194. }
198. /* Drier program to test above function*/
200. int main ()
202. {
204. / * Start with the empty list * /
206. struct node* head1 = NULL;
208. struct node* head2 = NULL;
210. struct node* INTERSECN = NULL;
212. struct node* unin = NULL;
216. /*create a linked lits 10->15->5->20 * /
218. Push (&head1, 20);
220. Push (&HEAD1, 4);
222. Push (&head1, 15);
224. Push (&head1, 10);
228. /*create a linked lits 8->4->2->10 * /
230. Push (&head2, 10);
232. Push (&HEAD2, 2);
234. Push (&HEAD2, 4);
236. Push (&HEAD2, 8);
240. INTERSECN = Getintersection (Head1, head2);
242. Unin = Getunion (Head1, head2);
246. printf ("\ n first list is \ n");
248. Printlist (HEAD1);
252. printf ("\ n Second list is \ n");
254. Printlist (HEAD2);
258. printf ("\ n intersection list is \ n");
260. Printlist (INTERSECN);
264. printf ("\ n Union list is \ n");
266. Printlist (Unin);
270. printf ("\ n");
272. return 0;
274. }

Time complexity: In this program, the time complexity of the linked list and the intersection operation is O (MN), M is the number of elements in the list 1, n is the element of the list 2.

Method 2 (Use merge sort):

Using this method, it is very similar to the operation of the set and intersection of the 2 linked lists. First, the 2 linked lists are sorted, and then the 2 linked lists are traversed, resulting in 2 table intersections and a set.

Here are the specific implementation steps:

1. The 1th list is sorted by a merge sort, and the time complexity of this operation is O (MLOGM). [Click here to see more]

2. Sorted by the 2nd linked list of the merge sort heap, the time complexity of this operation is O (NLOGN).

3. Linear traversal of 2 ordered linked lists, the intersection and the set of 2 linked lists are obtained. The time complexity of this operation is O (m+n). [This step is similar to finding the intersection and the set of an ordered array, which has been implemented before, click here to see more]

The time complexity of this method is O (mlogm+ Nlogn), which is better than the first method.

Method 3 (hash method):

Union (List1, List2)

First initialize the result linked list is null, create an empty hash table, traverse two linked lists, insert the elements of the list into the hash table, insert the element while checking the hash table when the element is already present, if the hash table does not exist in the element, the element is also inserted into the result list, If the hash table already exists, the element is ignored and the next element continues to traverse.

Intersection (List1, List2)

First initialize the result linked list to NULL, create an empty hash table, traverse List1, and insert each element in the List1 into the hash table. Then traverse List2, for elements in the List2, if it already exists in the hash table, then insert the element into the result list, if it does not exist with the hash table, then ignore the element, continue to traverse the next element.

The efficiency of this method depends on the implementation of the hash table technology, in general, this method is better than the above two.

Original address: http://www.geeksforgeeks.org/archives/18615?utm_source=rss&utm_medium=rss&utm_campaign= Union-and-intersection-of-two-linked-lists

Finding the set and intersection of linked lists