Merge Sort and apply it to an interview question

   Merge Sort is very efficient in sorting a list of elements with O(nlgn) complexity. It is used with divide and conquer strategy.

A few days ago, I came to an interview question, the description of the question is below:

There are two collections, list1 and list2, each collection has more than 10000 elements.

Please implement a method in Java without calling the system API; this method should return

a collection which contains all the elements of list1 and list2 and has no duplicate elements.

  The meaning of this question is to get the union of two sets.There are two points should be paid attention, first the duplicated elements in list1 and list2.The second is the duplicated elements in list1 or list2. We can implement a hash table to solve this issue. I try to solve this problem with merge sort idea. First I just want to merge the two lists but if you don't consider the order of the two lists, this method can't eliminate all the duplicate element.

  Below is the first version code in Python:

def merge_set(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] != right[j]:
            result.append(left[i])
            result.append(right[j])
        else:
            result.append(left[i])
            
        i += 1
        j += 1  
    
    while i < len(left):
        result.append(left[i])
        i += 1
    while j < len(right):
        result.append(right[j])
        j += 1
    
    return result

def union_set(S):
    n = len(S)
    if n <= 1:
        return S 
    # divide
    mid = int(len(S) / 2) #n // 2
    L1 = S[0:mid]
    L2 = S[mid:n]
    
    # conquer with recursion
    left = union_set(L1)
    right = union_set(L2)
    # merge resultx
    return merge_set(left, right)
    
    
if __name__ == '__main__':
    S = [10, 5, 5, 5, 7]
    #merge_sort(S)
    
    L = union_set(S)
    print L

It got problem when running the test, because the order of two lists.

Below is the code that can work fine with two lists, duplicated or no duplicated.

def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        elif left[i] == right[j]:   # do some modification when they are equal
            result.append(left[i])
            i += 1
            j += 1
        else:
            result.append(right[j])
            j += 1
    
    result += left[i:]
    result += right[j:]
    
    return result

def mergeset(lst):
    if len(lst) <= 1:
        return lst
    mid = int(len(lst) / 2)
    left = mergeset(lst[:mid])
    right = mergeset(lst[mid:])
    return merge(left, right)

if __name__ == "__main__":
    #L = mergeset([10, 5, 5, 5, 7])
    lst1 = [10, 5, 5, 5, 7]
    lst2 = [10, 5, 8, 8, 9, 11, 11, 12, 12]
    lst = lst1 + lst2
    L = mergeset(lst)
    print L

#    A = ['Hi', 'Ah', 'Wo', 'Hi', 'Hi']
#    L = mergeset(A)
#    print L
    
    
    

Bel ow is the merge sort with java and python code, I paste here just for a record.

package hello.sorting;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class MergeSort<T> {

	// the list to be sorted
	private List<T> lst;
	
	public MergeSort() {
		//lst = new ArrayList<T>(n);
		//this.lst = lst;
	}
	
	public void init(List<T> lst) {
		this.lst = lst;
	}
	
	/**
	 * merge two lists
	 * @param left
	 * @param right
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public List<T> merge(List<T> left, List<T> right) {
		List<T> result = new ArrayList<T>();
		int i = 0, j = 0;
		
		while(i < left.size() && j < right.size()) {
			
			if(((Comparable)left.get(i)).compareTo(((Comparable)right.get(j))) <= 0) {
				result.add(left.get(i));
				i += 1;
			}
			else {
				result.add(right.get(j));
				j += 1;
			}
		}
		
		while(i < left.size()) {
			result.add(left.get(i));
			i++;
		}
	    
		while(j < right.size()) {
			result.add(right.get(j));
			j++;
		}
		
		return result;
	}
	
	/**
	 * merge sort with dividing and conquering
	 * @param lst
	 * @return
	 */
	public List<T> mergeSort(List<T> lst) {
		if(lst.size() <= 1) {
			return lst;
		}
		
		// divide
		int mid = (int)(lst.size() / 2);
		List<T> L = lst.subList(0, mid);
		List<T> R = lst.subList(mid, lst.size());
		
		// conquer with recursion
		List<T> left = mergeSort(L);
		List<T> right = mergeSort(R);
		
		// merge the left and right list
		return merge(left, right);
	}
	
	/**
	 * generate a random integer list less than 100
	 * @param n
	 * @return
	 */
	public List<Integer> generateRandom(int n) {
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random();
		
		for(int i = 0; i < n; i++) {
			list.add(r.nextInt() % 100);
		}
		
		return list;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MergeSort<Integer> ms = new MergeSort<Integer>();
		List<Integer> lst = ms.generateRandom(10);
		for(int i = 0; i < lst.size(); i++) {
			System.out.print(" " + lst.get(i));
		}
		System.out.println();

		ms.init(lst);
		
		List<Integer> result = ms.mergeSort(lst);
		
		for(int i = 0; i < result.size(); i++) {
			System.out.print(" " + result.get(i));
		}
		System.out.println();
		System.out.println("Ha..");
	}

}

Python code:

def merge(S1, S2, S):
    '''
    Merge two sorted python lists S1 and S2 into properly size list S.
    '''
    i = j = 0
    while i + j < len(S):
        if j == len(S2) or (i < len(S1) and S1[i] < S2[j]):
            S[i + j] = S1[i]
            i += 1
        else:
            S[i + j] = S2[j]
            j += 1


def merge_sort(S):
    '''
    Sort the elements of python list S using merge-sort algorithm
    '''
    n = len(S)
    if n < 2:
        return 
    # divide
    mid = n // 2
    S1 = S[0:mid]
    S2 = S[mid:n]
    # conquer with recursion
    merge_sort(S1)
    merge_sort(S2)
    # merge result
    merge(S1, S2, S)