一种复杂度为O(1)获取两个List差集的算法(JAVA)

一种复杂度为O(1)获取两个List差集的算法(JAVA)

1.模型图

两个List的差集为A，合集为B

2.算法思路

1，首先两个指针同时指向两个list的初始位置，若如果当两个值相等时，也即图一所示，指针同时加1，变为图形2

2，当两边list的值较大的一方进行指针加1，另一方list保持不变，如图3

3，当相等时继续指针加1，如图4

4，当两边list的值较大的一方进行指针加1，另一方list保持不变，如图5

5，当两个list，其中有一个执行结束时，跳出循环，如图6

6，然后继续处理后续未结束那个list，直到另一list也结束，如图7

                                      图1

 

                                 图2                                                            

           

                                   图3

     

                                  图4                                                          

                                    图5

                                     图6

                                  图7

3.代码实现

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * 
 * @author liujie
 *
 *         两个排好序的list获取差集，并集和合集
 */
public class SortList {

	private static final long N = 5000000;

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<Integer>();
		List<Integer> list2 = new ArrayList<Integer>();
		long t1 = System.currentTimeMillis();
		for (int i = 0; i < N; i++) {
			list1.add(i);
			list2.add(i+1000);
		}
		long t2 = System.currentTimeMillis();

		Iterator<Integer> it1 = list1.iterator();
		Iterator<Integer> it2 = list2.iterator();
		System.out.println("**********list1**************");
//		while (it1.hasNext()) {
//			System.out.println("it1.next() = " + it1.next());
//		}
		System.out.println("**********list2**************");
//		while (it2.hasNext()) {
//			System.out.println("it2.next() = " + it2.next());
//		}
		
		List<Integer> list3 = new ArrayList<Integer>();
		Collections.sort(list1);
		long t3 = System.currentTimeMillis();
		Collections.sort(list2);
		long t4 = System.currentTimeMillis();
		list3 = getASubB(list1, list2);
		long t5 = System.currentTimeMillis();
		System.out.println("**********list3**************");
		Collections.sort(list3);
		Iterator<Integer> it3 = list3.iterator();
//		while(it3.hasNext())
//		{
//			System.out.println("it3.next() = " + it3.next());
//		}
		
		System.out.println("(t2 - t1) =" + (t2 -t1));
		System.out.println("(t3 - t2) =" + (t3 -t2));
		System.out.println("(t4 - t3) =" + (t4 -t3));
		System.out.println("(t5 - t4) =" + (t5 -t4));
		
	}

	/**
	 * 两个list的差集
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	private static List<Integer> getASubB(List<Integer> a, List<Integer> b) {
		List<Integer> c = new ArrayList<Integer>();
		int i = 0;
		int j = 0;
		while(true){
			if (a.get(i).equals(b.get(j))) {
				i++;
				j++;
				if(j >= b.size())
				{
					break;
				}
				if(i >= a.size())
				{
					break;
				}
			}
			if (a.get(i).compareTo(b.get(j)) > 0) {
				c.add(b.get(j));
				j++;	
				if(j >= b.size())
				{
					break;
				}
			}
			if (a.get(i).compareTo(b.get(j)) < 0) {
				c.add(a.get(i));
				i++;
				if(i >= a.size())
				{
					break;
				}
			}

		}
		System.out.println("i = " + i + ", j = " + j);
		// 临界条件处理
		while (i < a.size()) {
			c.add(a.get(i));
			i++;
		}

		while (j < b.size()) {
			c.add(b.get(j));
			j++;
		}
		
		return c;
	}
}

4，执行结果

针对500万数据进行测试所花费的时间为105ms，效果相当的好！