算法练习 - 判断是否存在相交数组

在风中的意志 2020-07-29 18:26:33

198

分类专栏： 1. 算法 -------1.4. 算法练习文章标签：算法练习数组相交

本文链接：https://blog.csdn.net/u010416101/article/details/107669511

版权

题目

判断数据内，元素是否有交集. 数组内的值都是连续值.
例如：[[1,6], [5,9],[16,30],[8,10]]
输入: 一个二维数组.
返回: 布尔类型数据 true or false.

解题思路

思路1: 两两比较.

两两比较主要包括4种情况.

Case1: 不相交
在这里插入图片描述

if(A.尾巴>B.头){
	resultFlag = false;
}

Case2: 不相交

在这里插入图片描述

if(B.尾巴>A.头){
	resultFlag = false;
}

Case3: 左交

在这里插入图片描述

if(A.头<=B.头&&A.尾>=B.头){
	resultFlag = true;
}

case4: 右交
在这里插入图片描述

if(B.头<=A.头&&B.尾>=A.头){
	resultFlag = true;
}

由上面的4图可以知道. 我们需要知道的相交情况. 主要就是2种. 左交和右交.
左交和右交其实还可以做一个判断. 将A.头和B.头先进行比较, 选择头节点小的作为先比较节点.(一个简单优化, 可以设置也可以不设置.)

思路1: 简单的编码如下所示

	public static boolean insetOrNotBetweenTwoArrayMethod1(int []arrayA,int arrayB[]) {
		// 返回值结果
		boolean flag = false;
		if(arrayA.length>0&& arrayB.length>0) {
			int beginA = arrayA[0];
			int endA = arrayA[arrayA.length-1];
			int beginB = arrayB[0];
			int endB = arrayB[arrayB.length-1];
			// 左交
			if(beginA<=beginB&&endA>=beginB) {
				flag = true;
			}
			// 右交
			else if(beginB<=beginA&&endB>=beginA) {
				flag = true;
			}
			// 其余2种情况都是不相交的 可以不用写
			else if(endA >=beginB || endB>=beginA) {
				flag = false;
			}
		}
		return flag;
	}
	// 思路1 左交 右交
	public static boolean insetOrNotInArraysMethod1(int array[][]) {
		boolean flag = false;
		int arrayCount = array.length;
		for(int i=0;i<arrayCount;i++) {
			for(int j=i+1;j<arrayCount;j++) {
				// 两两比较
				flag = flag & insetOrNotBetweenTwoArrayMethod1(array[i],array[j]);
				if(flag) {break;}
			}
			if(flag) {break;}
		}
		return flag;
	}

优点：利用规律一目了然.
缺点: 需要两两比较.

思路2: 排序后比较.

思路1介绍了两两进行比较. 两两比较的复杂度为O(N^2). 思路2为先将2者按照头节点排序, 随后进行比较.

比如例子:

例如：[[1,6], [5,9],[16,30],[8,10]]
排序后: [[1,6], [5,9],[8,10],[16,30]]

排序之后, 比较第二个节点的值头是否在第一个之内即可. 也就是我们说的左交情况.
在这里插入图片描述

步骤1: 排序.
步骤2: for(1...N) 比较是否存在左交情况.

这边有一个特别的情况, 那就是相等. 对于相等来说, 比如[1,5],[1,6]或者[1,6][1,5]. 可以看到比较例子并没有什么影响.

	// 思路2 排序后比较
	public static boolean insetOrNotInArraysMethod2(int array[][]) {
		boolean flag = false;
		int arrayCount = array.length;
		// 我们这边选择最简单的插入排序.
		for(int i=0;i<arrayCount;i++) {
			for(int j=i;j>0;j--) {
				if(array[j][0]<array[j-1][0]) {
					swapTwoArray(array,j,j-1);
				}else {
					break;
				}
			}
		}
		// 随后依次判断是否存在左交情况
		for(int i=1;i<arrayCount;i++) {
			if(array[i][0]>=array[i-1][0] &&array[i][0] <=array[i-1][array[i-1].length-1]) {
				flag = true;
				break;
			}
		}
		return flag;
	}

思路3: 穷举.

所谓的穷举就是对于思路1中的两个数组不断迭代判断. 效率比较低. 是一种最先想到的思路.

	public static boolean insetOrNotBetweenTwoArrayMethod3(int[] arrayA, int arrayB[]) {
		// 返回值结果
		boolean flag = false;
		if (arrayA.length > 0 && arrayB.length > 0) {
			for(int i=0;i<arrayA.length;i++) {
				for(int j=0;j<arrayB.length;j++) {
					if(arrayA[i]==arrayB[j]) {
						flag = true;
						break;
					}
				}
				if(flag) {break;}
			}
		}
		return flag;
	}

思路4: hash槽.

对于空间无限大的情况. 可以使用空间换时间的做法. 设置一个Hash槽. 将数组存进去, 随后依次遍历即可. 可以使用Set和Map这样的数据结构都可以.
对于JDK而言, HashSet就是依托于HashMap进行实现都. 如果不用记录次数和其他信息, 可以选择Set. 如果需要的话可以选择Map. 思路相关代码如下所示:

思路4 相关代码

	public static boolean insetOrNotInArraysMethod4(int array[][]) {
		boolean flag = false;
		//
		HashSet<Integer> set = new HashSet<>();
		
		for(int i=0;i<array.length;i++) {
			for(int j=0;j<array[i].length;j++) {
				// 判断是否已经存在
				if(set.contains(array[i][j])) {
					flag = true;
					break;
				}else {
					// 不然将其放入
					set.add(array[i][j]);
				}
			}
			if(flag) {break;}
		}
		return flag;
	}

测试用例

Case1 空二纬数组. []
Case2 单个二维数组. [[1,5]]
Case3 存在头节点相等的数组. [[2,4],[2,9]]
Case4 存在尾节点相等的数组. [[3,4],[4,4]]
Case5 正常测试用例.[[1,6], [5,9],[16,30],[8,10]]

使用Junit测试. 测试用例代码如下所示:

	@Test
	public void testCase() {
		// * Case1 空二纬数组. `[]`
		int testArray1[][] = new int[0][];
		boolean result1 = insetOrNotInArraysMethod1(testArray1);
		Assert.assertEquals(result1,false);
		
		// * Case2 单个二维数组. `[[1,5]]`
		int testArray2[][] = new int[1][];
		testArray2[0] = new int[]{1,2,3,4,5};
		boolean result2 = insetOrNotInArraysMethod1(testArray2);
		Assert.assertEquals(result2,false);

		// * Case3 存在头节点相等的数组. `[[2,4],[2,9]]`
		int testArray3[][] = new int[2][];
		testArray3[0] = new int[]{2,3,4,5};
		testArray3[1] = new int[]{2,3,4,5,6,7,8,9};
		boolean result3 = insetOrNotInArraysMethod1(testArray3);

		Assert.assertEquals(result3,true);


		// * Case4 存在尾节点相等的数组. `[[3,4],[4,4]]`
		int testArray4[][] = new int[2][];
		testArray4[0] = new int[]{3,4};
		testArray4[1] = new int[]{4};
		boolean result4 = insetOrNotInArraysMethod1(testArray4);
		Assert.assertEquals(result4,true);


		// * Case5 正常测试用例.`[[1,6], [5,9],[16,30],[8,10]]`
		int testArray5[][] = new int[4][];
		testArray5[0] = new int[]{1,2,3,4,5,6};
		testArray5[1] = new int[]{5,6,7,8,9};
		testArray5[2] = new int[]{16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
		testArray5[3] = new int[]{8,9,10};
		boolean result5 = insetOrNotInArraysMethod1(testArray5);
		Assert.assertEquals(result5,false);

	}