如何在O（n）中找到两个链表之间缺少的元素？

Question

I have two Singly Linked Lists of Integer. One of them is a subset of another (the order of numbers is different). What is the best way (regarding performance) to find a number which the first list does contain and the second one does not?

My thought is first to sort them (using merge sort) and then just compare element by element. So, it takes O(nlogn+mlogm+n) , but a better O(n) soltuion should exist.

Answer 1

This is O(n) solution both in Time and Space.

Logic

Lets say the original Linked List has size N we'll call it LL1 and second Linked List as LL2 .

=> Prepare a Hasmap of size N, key would be the numbers in the LL1 and value would be frequency in LL2

 HashMap<Integer,Integer> map= new HashMap<Integer,Integer>();

=> Start traversing LL1 and set the frequency to 0 for all the Numbers
By the time all values in LL1 is iterated, you have all the Numbers present in HashMap with frequency = 0

 map.put(key, 0);

=> Now start looping through the LL2 , pick the numbers using them as key and increment the value by 1 .
By the time all values in LL2 is iterated, you have all the common numbers present in both LL1 and LL1 inside HashMap having frequency > 0

  map.put(key, map.get(key) + 1);

=> Now start traversing the hasmap , searching for value = 0 , when found, print the key as this number present only in LL1 and not in LL2

for (map.Entry<Integer,Integer> entry : map.entrySet())
{
    if(entry.getValue() == 0)
        System.out.println(entry.getKey());//This is a loner
}

2 Iterations and O(n) memory with O(n) time.

Answer 2

You can put both of them in different maps and then compare them. Putting in a map should be 2 single for loops of m & n and look up time for map is 1.

Answer 3

HashSet is the best data structure to use in this case. With this code, you can achieve your results in O(n). Let me know if you have more conditions, i can suggest something accordingly.

 public class LinkedList {

        private ListNode head;

        public ListNode getHead() {
            return head;
        }
    }

    public class ListNode {

        public int value;
        public ListNode next;

        ListNode(int value) {
            this.value = value;
        }
    }

    public class UtilClass{
       public static int checkLists(LinkedList list1, LinkedList list){
            ListNode head = myList2.getHead();

            HashSet<Integer> hashSet = new HashSet<Integer>();

            while(head!=null){
                hashSet.add(head.value);
                head = head.next;
            }

            head = myList.getHead();

            while(head!=null){
                boolean b = hashSet.add(head.value);
                if(b == true) return head.value;
                head = head.next;
            }
             return -1111;
    }
    }

Answer 4

You can use removeAll method. All you have to do is create a method that accepts two lists, one is the original and the other is the sublist, then, return a list of missing elements:

List getMissing(List original, List sub){
     original.removeAll(sub);
     return original;
}

This runs in quadratic time though.

If you really want to force it to run in linear time, O(n), then you have to write custom class that wrap your inputs such that for each input, there is a flag that monitors whether or not it has been added to the sublist. You can also design a class that facilitates addition and deletion of elements while monitoring the contents of both lists.

Answer 5

Let N = m+n.

• Add the lists. As they are linked lists, this is cheap O(1).
• Sort them O(N log N) - maybe better have used ArrayList.
• Walk the list and on not finding a consecutive pair {x, x} you have found a missing one, O(N), as the second list is a subset.

So O(N . log N) .

As the lists are not ordered, any speedup consists of something like sorting, and that costs. So O(N.log N) is fine.

If you want O(N) you could do it as follows (simplified, using positive numbers):

BitSet present = new BitSet(Integer.MAX_VALUE);
for (int value : sublist)
    present.set(value);
for (int value : list)
    if (!present.isSet(value)) {
        System.out.println("Missing: " + value);
        break;
    }

This trades memory against time. Mind this answer might not be accepted, as the memory is 2 ^MAX_VALUE which to initialize/clear costs time too.

The possible < O(N log N) solutions

The most intelligent answer might be (quasi) sorting cooperatively both lists. And during the sort detect the missing element. Something like picking a haphazard "median" element and shifting shifting indices to split the lists, and divide and conquer.

If the list sizes differ by 1

Then you would only need to make the sums for every list, the difference being the missing value: O(N). Works with overflow.