# Python | Check if two lists have at-least one element common

Last Updated : 13 Apr, 2023

Given two lists a, b. Check if two lists have at least one element common in them.

Examples:

```Input : a = [1, 2, 3, 4, 5]
b = [5, 6, 7, 8, 9]
Output : True

Input : a=[1, 2, 3, 4, 5]
b=[6, 7, 8, 9]
Output : False```

Method 1: Traversal of List

Using traversal in two lists, we can check if there exists one common element at least in them. While traversing two lists if we find one element to be common in them, then we return true. After complete traversal and checking, if no elements are same, then we return false.

## Python

 `# Python program to check ` `# if two lists have at-least ` `# one element common` `# using traversal of list`   `def` `common_data(list1, list2):` `    ``result ``=` `False`   `    ``# traverse in the 1st list` `    ``for` `x ``in` `list1:`   `        ``# traverse in the 2nd list` `        ``for` `y ``in` `list2:` `  `  `            ``# if one common` `            ``if` `x ``=``=` `y:` `                ``result ``=` `True` `                ``return` `result ` `                `  `    ``return` `result` `    `  `# driver code` `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``5``, ``6``, ``7``, ``8``, ``9``]` `print``(common_data(a, b))`   `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``6``, ``7``, ``8``, ``9``]` `print``(common_data(a, b))`

Output:

```True
False```

Time complexity: O(n*m), where n and m are the lengths of the input lists.
Auxiliary space: O(1).

Method 2 : Using Set and Property

Using set’s and property, if there exists at least one common element then set(a)&set(b) returns a positive integer, if it does not contains any positive integer, then it returns 0. So we insert a in set_a and b in set_b and then check if set_a & set_b for a positive integer or not.

## Python

 `# Python program to check ` `# if two lists have at-least ` `# one element common` `# using set and property`   `def` `common_member(a, b):` `    ``a_set ``=` `set``(a)` `    ``b_set ``=` `set``(b)` `    ``if` `(a_set & b_set):` `        ``return` `True` `    ``else``:` `        ``return` `False` `        `    `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``5``, ``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))`   `a ``=``[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=``[``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))`

Output:

```True
False```

Time complexity: O(m + n), where m and n are the lengths of the input lists a and b, respectively.
Auxiliary space: O(m + n), for creating the two sets a_set and b_set.

Method 3 : Using Set Intersection

Using set’s intersection inbuilt function. a_set.intersection(b_set) returns a positive integer if there is at least one element in common, else it returns 0. So we insert a in set_a and b in set_b and then check a_set.intersection(b_set), and returns depending on the value.

## Python

 `# Python program to check ` `# if two lists have at-least ` `# one element common` `# using set intersection`   `def` `common_member(a, b):` `    ``a_set ``=` `set``(a)` `    ``b_set ``=` `set``(b)` `    ``if` `len``(a_set.intersection(b_set)) > ``0``:` `        ``return``(``True``) ` `    ``return``(``False``)   `   `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``5``, ``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))`   `a ``=``[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=``[``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))`

Output:

```True
False```

Time complexity: O(n), where n is the size of the larger list between a and b.
Auxiliary space: O(n), where n is the size of the larger list between a and b.

Another approach that can be used to check if two lists have at least one common element is to use the Counter class from the collections module. The Counter class is a subclass of dict that is used to count the occurrences of elements in a list.

Here is an example of how the Counter class can be used to check if two lists have at least one common element:

## Python3

 `from` `collections ``import` `Counter`   `def` `have_common_element(list1, list2):` `    ``counter1 ``=` `Counter(list1)` `    ``counter2 ``=` `Counter(list2)` `    ``for` `element, count ``in` `counter1.items():` `        ``if` `element ``in` `counter2 ``and` `count > ``0``:` `            ``return` `True` `    ``return` `False`   `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``5``, ``6``, ``7``, ``8``, ``9``]` `print``(have_common_element(a, b))  ``# True`   `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``6``, ``7``, ``8``, ``9``]` `print``(have_common_element(a, b))  ``# False`

Output

```True
False```

Time complexity: O(n+m), where n is the length of list1 and m is the length of list2.

Auxiliary space: O(k), where k is the number of unique elements in both lists combined.

Method #5 : Using operator.countOf() method

## Python3

 `import` `operator as op` `# Python code to check if two lists` `# have any element in common`   `# Initialization of list` `list1 ``=` `[``1``, ``3``, ``4``, ``55``]` `list2 ``=` `[``90``, ``1``, ``22``]`   `flag ``=` `0`   `# Using in to check element of` `# second list into first list` `for` `elem ``in` `list2:` `    ``if` `op.countOf(list1, elem) > ``0``:` `        ``flag ``=` `1`   `# checking condition` `if` `flag ``=``=` `1``:` `    ``print``(``"True"``)` `else``:` `    ``print``(``"False"``)`

Output

`True`

Time Complexity: O(N)
Auxiliary Space: O(1)

Method 4: Using the any() function and the list comprehension method.

This methos uses the any() function along with list comprehension to check if two lists have at least one common element. The list comprehension creates a list of boolean values by comparing each element of the first list to each element of the second list. The any() function returns True if at least one of the boolean values in the list is True, indicating that there is at least one common element between the two lists.

Algorithm:

Create a boolean list using list comprehension that compares each element of the first list to each element of the second list.
Check if any() of the boolean values in the list is True.
If any() is True, return True. Otherwise, return False.

## Python3

 `def` `common_member(a, b):` `    ``return` `any``(i ``in` `b ``for` `i ``in` `a)` ` `  `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=` `[``5``, ``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))  ``# True` ` `  `a ``=``[``1``, ``2``, ``3``, ``4``, ``5``]` `b ``=``[``6``, ``7``, ``8``, ``9``]` `print``(common_member(a, b))  ``# False`

Output

```True
False```

Time complexity: O(n*m), where n and m are the lengths of the input lists.
Auxiliary space: O(1).