两集合（数组）求交集

最新推荐文章于 2024-05-15 19:26:44 发布

原创最新推荐文章于 2024-05-15 19:26:44 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#allocation #list #algorithm #integer #null #string

java 同时被 2 个专栏收录

29 篇文章

订阅专栏

algorithm

7 篇文章

订阅专栏

本文介绍两种排序交集算法实现及性能对比，通过基准测试验证不同场景下算法的效率。结果显示，双排序法在大多数情况下更优，特别是针对大小不等的数据集。

算法一步骤（SortSortIntersectionAlgorithm）：

1、sort集合一

2、sort集合二

3、同时遍历已排序的两集合，进行计算

/** * */ package algorithm.intersection; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; /** * sort sort intersection algorithm * * @author yangwm Oct 19, 2010 1:09:12 PM */ public class SortSortIntersectionAlgorithm { /** * sort + sort + intersection * * @param left * @param right * @return */ public static List<Integer> intersection(List<Integer> left, List<Integer> right) { int leftSize = left.size(); int rightSize = right.size(); /* * sort */ Collections.sort(left); Collections.sort(right); /* * allocation maximum space for result */ List<Integer> result = null; if (leftSize < rightSize) { result = new ArrayList<Integer>(leftSize); } else { result = new ArrayList<Integer>(rightSize); } /* * intersection calculate */ int leftIdx = 0; int rightIdx = 0; while (leftIdx < leftSize && rightIdx < rightSize) { if (left.get(leftIdx) < right.get(rightIdx)) { leftIdx++; } else if (left.get(leftIdx) > right.get(rightIdx)) { rightIdx++; } else { // == result.add(left.get(leftIdx)); //result.set(resultIdx, left.get(leftIdx)); leftIdx++; rightIdx++; } } /* * actual size of result */ return result; } /** * sort + sort + intersection * * @param left * @param right * @return */ public static int[] intersection(int[] left, int[] right) { /* * allocation maximum space for result */ int[] result = null; if (left.length < right.length) { result = new int[left.length]; } else { result = new int[right.length]; } /* * sort */ Arrays.sort(left); Arrays.sort(right); /* * intersection calculate */ int leftIdx = 0; int rightIdx = 0; int resultIdx = 0; while (leftIdx < left.length && rightIdx < right.length) { if (left[leftIdx] < right[rightIdx]) { leftIdx++; } else if (left[leftIdx] > right[rightIdx]) { rightIdx++; } else { // == result[resultIdx] = left[leftIdx]; leftIdx++; rightIdx++; resultIdx++; } } /* * actual size of result */ return Arrays.copyOf(result, resultIdx); } /** * @param args */ public static void main(String[] args) { List<Integer> left = new ArrayList<Integer>(Arrays.<Integer>asList(new Integer[] { 5, 9, 2, 8, 11 })); List<Integer> right = new ArrayList<Integer>(Arrays.<Integer>asList(new Integer[] { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 })); System.out.println("------SortSortIntersectionAlgorithm List intersection-------"); /* * intersection and test print */ long begin = System.nanoTime(); List<Integer> result = intersection(left, right); long end = System.nanoTime(); System.out.println("cosume: " + (end - begin) + " ns"); System.out.println(result); //--------------------------------------------------------- int[] leftArray = { 5, 9, 2, 8, 11 }; int[] rightArray = { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 }; System.out.println("------SortSortIntersectionAlgorithm Array intersection-------"); /* * intersection and test print */ begin = System.nanoTime(); int[] resultArray = intersection(leftArray, rightArray); end = System.nanoTime(); System.out.println("cosume: " + (end - begin) + " ns"); System.out.println(Arrays.toString(resultArray)); } } /* ------SortSortIntersectionAlgorithm List intersection------- cosume: 18086935 ns [2, 5, 8, 9, 11] ------SortSortIntersectionAlgorithm Array intersection------- cosume: 389994 ns [2, 5, 8, 9, 11] */

算法二步骤（SortIntersectionAlgorithm）：

1、sort集合一

2、遍历集合二到已排序的集合一种进行查找，并计算

/** * */ package algorithm.intersection; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; /** * sort intersection algorithm * * @author yangwm Oct 19, 2010 1:09:12 PM */ public class SortIntersectionAlgorithm { /** * sort + sort + intersection * * @param left * @param right * @return */ public static List<Integer> intersection(List<Integer> left, List<Integer> right) { /* * if left size greater than right size then swap of address */ if (left.size() > right.size()) { List<Integer> swap = left; left = right; right = swap; } int leftSize = left.size(); int rightSize = right.size(); //System.out.println(leftSize + ", " + rightSize); /* * sort */ Collections.sort(left); /* * allocation maximum space for result */ List<Integer> result = null; if (leftSize < rightSize) { result = new ArrayList<Integer>(leftSize); } else { result = new ArrayList<Integer>(rightSize); } /* * intersection calculate */ int rightIdx = 0; while (left.size() > 0 && rightIdx < rightSize) { // int rightValue = right.get(rightIdx); rightIdx++; int resultValue = Collections.binarySearch(left, rightValue); if (resultValue > -1) { result.add(rightValue); /* reduce left left.remove(resultValue); */ } } //System.out.println(left.size() + ", " + rightIdx + ", " + result.size()); /* * actual size of result */ return result; } /** * sort + intersection * * @param left * @param right * @return */ public static int[] intersection(int[] left, int[] right) { /* * if left size greater than right size then swap of address */ if (left.length > right.length) { int[] swap = left; left = right; right = swap; } //System.out.println(left.length + ", " + right.length); /* * allocation maximum space for result */ int[] result = null; if (left.length < right.length) { result = new int[left.length]; } else { result = new int[right.length]; } /* * sort */ Arrays.sort(left); /* * intersection calculate */ int rightIdx = 0; int resultIdx = 0; while (left.length > 0 && rightIdx < right.length) { // int rightValue = right[rightIdx]; rightIdx++; int resultValue = Arrays.binarySearch(left, rightValue); if (resultValue > -1) { result[resultIdx] = rightValue; resultIdx++; /* reduce left int numMoved = left.length - resultValue - 1; //System.out.println(left.length + ", " + resultValue + ", " + numMoved); if (numMoved > 0) { System.arraycopy(left, resultValue+1, left, resultValue, numMoved); int[] leftTemp = new int[left.length - 1]; System.arraycopy(left, 0, leftTemp, 0, leftTemp.length); left = leftTemp; } else if(numMoved == 0) { left = new int[0]; } */ } } //System.out.println(left.length + ", " + rightIdx + ", " + resultIdx); /* * actual size of result */ return Arrays.copyOf(result, resultIdx); } /** * @param args */ public static void main(String[] args) { List<Integer> left = new ArrayList<Integer>(Arrays.<Integer>asList(new Integer[] { 5, 9, 2, 8, 11 })); List<Integer> right = new ArrayList<Integer>(Arrays.<Integer>asList(new Integer[] { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 })); System.out.println("------SortSortIntersectionAlgorithm List intersection-------"); /* * intersection and test print */ long begin = System.nanoTime(); List<Integer> result = intersection(left, right); long end = System.nanoTime(); System.out.println("cosume: " + (end - begin) + " ns"); System.out.println(result); //--------------------------------------------------------- int[] leftArray = { 5, 9, 2, 8, 11 }; int[] rightArray = { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 }; System.out.println("------SortSortIntersectionAlgorithm Array intersection-------"); /* * intersection and test print */ begin = System.nanoTime(); int[] resultArray = intersection(leftArray, rightArray); end = System.nanoTime(); System.out.println("cosume: " + (end - begin) + " ns"); System.out.println(Arrays.toString(resultArray)); } } /* ------SortSortIntersectionAlgorithm List intersection------- 0, 8, 5 cosume: 1096787 ns [2, 8, 9, 11, 5] ------SortSortIntersectionAlgorithm Array intersection------- cosume: 220978 ns [2, 8, 9, 11] */

算法的基准测试一（集合一比较小，集合二比较大）：

包含：

1、JDK List retainAll

2、SortSortIntersectionAlgorithm List intersection

3、SortSortIntersectionAlgorithm Array intersection

4、SortIntersectionAlgorithm List intersection

5、SortIntersectionAlgorithm Array intersection

/** * */ package algorithm.intersection; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; /** * sort intersection algorithm bench * * @author yangwm Oct 19, 2010 1:59:16 PM */ public class IntersectionAlgorithmBench { /** * @param args */ public static void main(String[] args) { /* * */ int leftTotal = 2000; int rightTotal = 1000000; int factor = (rightTotal / leftTotal) * (new Random().nextInt(5) + 1); /* * test data */ List<Integer> leftList = new ArrayList<Integer>(leftTotal); for (int i = 0; i < leftTotal; i++) { leftList.add(i * factor); } Collections.shuffle(leftList); List<Integer> rightList = new ArrayList<Integer>(rightTotal); for (int i = 0; i < rightTotal; i++) { rightList.add(i); } Collections.shuffle(rightList); System.out.println("test begin leftTotal: " + leftTotal + ", rightTotal: " + rightTotal + ", factor: " + factor); System.out.println("test data leftList.size(): " + leftList.size() + ", rightList.size(): " + rightList.size()); //--------------------------------------------------------- List<Integer> left = new ArrayList<Integer>(leftList); List<Integer> right = new ArrayList<Integer>(rightList); System.out.println("-----------------JDK List retainAll-----------------"); /* * intersection and test print */ long begin = System.currentTimeMillis(); left.retainAll(right); long end = System.currentTimeMillis(); System.out.println("cosume: " + (end - begin) + " ms"); System.out.println("left.size(): " + left.size()); //----------------------------------------------------------------- left = new ArrayList<Integer>(leftList); right = new ArrayList<Integer>(rightList); System.out.println("------SortSortIntersectionAlgorithm List intersection-------"); /* * intersection and test print */ begin = System.currentTimeMillis(); List<Integer> result = SortSortIntersectionAlgorithm.intersection(left, right); end = System.currentTimeMillis(); System.out.println("cosume: " + (end - begin) + " ms"); System.out.println("result.size(): " + result.size()); //----------------------------------------------------------------- int[] leftArray = new int[leftList.size()]; for (int i = 0; i < leftArray.length; i++) { leftArray[i] = leftList.get(i); } int[] rightArray = new int[rightList.size()]; for (int i = 0; i < rightArray.length; i++) { rightArray[i] = rightList.get(i); } System.out.println("------SortSortIntersectionAlgorithm Array intersection-------"); /* * intersection and test print */ begin = System.currentTimeMillis(); int[] resultArray = SortSortIntersectionAlgorithm.intersection(leftArray, rightArray); end = System.currentTimeMillis(); System.out.println("cosume: " + (end - begin) + " ms"); System.out.println("resultArray.length: " + resultArray.length); //----------------------------------------------------------------- left = new ArrayList<Integer>(leftList); right = new ArrayList<Integer>(rightList); System.out.println("------SortIntersectionAlgorithm List intersection-------"); /* * intersection and test print */ begin = System.currentTimeMillis(); result = SortIntersectionAlgorithm.intersection(left, right); end = System.currentTimeMillis(); System.out.println("cosume: " + (end - begin) + " ms"); System.out.println("result.size(): " + result.size()); //----------------------------------------------------------------- leftArray = new int[leftList.size()]; for (int i = 0; i < leftArray.length; i++) { leftArray[i] = leftList.get(i); } rightArray = new int[rightList.size()]; for (int i = 0; i < rightArray.length; i++) { rightArray[i] = rightList.get(i); } System.out.println("-------SortIntersectionAlgorithm Array intersection-------"); /* * intersection and test print */ begin = System.currentTimeMillis(); resultArray = SortIntersectionAlgorithm.intersection(leftArray, rightArray); end = System.currentTimeMillis(); System.out.println("cosume: " + (end - begin) + " ms"); System.out.println("resultArray.length: " + resultArray.length); } } /* vm args: -server -Xms256m -Xmx256m -XX:PermSize=64m(使用left列表移除元素) test begin leftTotal: 2000, rightTotal: 1000000, factor: 1500 test data leftList.size(): 2000, rightList.size(): 1000000 -----------------JDK List retainAll----------------- cosume: 31640 ms left.size(): 667 ------SortSortIntersectionAlgorithm List intersection------- cosume: 687 ms result.size(): 667 ------SortSortIntersectionAlgorithm Array intersection------- cosume: 234 ms resultArray.length: 667 ------SortIntersectionAlgorithm List intersection------- 1333, 1000000, 667 cosume: 313 ms result.size(): 667 -------SortIntersectionAlgorithm Array intersection------- cosume: 125 ms resultArray.length: 667 vm args: -server -Xms256m -Xmx256m -XX:PermSize=64m(未使用left列表移除元素) test begin leftTotal: 2000, rightTotal: 1000000, factor: 1500 test data leftList.size(): 2000, rightList.size(): 1000000 -----------------JDK List retainAll----------------- cosume: 31797 ms left.size(): 667 ------SortSortIntersectionAlgorithm List intersection------- cosume: 828 ms result.size(): 667 ------SortSortIntersectionAlgorithm Array intersection------- cosume: 219 ms resultArray.length: 667 ------SortIntersectionAlgorithm List intersection------- cosume: 312 ms result.size(): 667 -------SortIntersectionAlgorithm Array intersection------- cosume: 125 ms resultArray.length: 667 */

算法的基准测试二（集合一与集合二一样大）：

包含：

1、SortSortIntersectionAlgorithm Array intersection

2、SortIntersectionAlgorithm Array intersection

结果：

1、两集合都排序后再比较，效率比较高一些

2、但一集合很小、另一集合很大时候，使用小集合排序后、大集合到小集合中进行二分查找（找到后移除小集合中该元素并缩小集合大小，节约下次查找成本对性能提升不大），比较划算

3、Array计算效率明显高于List（快几倍呢）