算法两则Java：数组中两元素之和与寻找单个元素

目录

实现思路

代码展示

代码讲解

实现思路

思路一

思路二

代码展示

---

两元素之和实现思路

数组中两元素之和（简称两数之和）到底讲的是什么东西呢？它讲的是，在一个数组中，寻找两个元素的和，该和等于目标数字，并返回两元素索引。比如数组{1，4，2，3}，我们的目标数字是7（寻找7）。那很显然，4+3=7，那么就返回{1，3}，这分别是元素4和3在数组中的索引。

我们现在知道了它是什么东西，那该如何实现它呢？我们考虑使用最简单直接的方法：暴力组合。该方法的思想是，把数组里面所有元素都组合一遍，看看哪个和等于目标数字。比如在上面这个数组中我们尝试：1+4等于7么？不等于，就尝试下一个组合。1+2！=7，1+3！=7，4+2！=7，4+3==7。于是返回4，3在数组中的索引。如果找遍了数组都没有找到正确的组合，就说明目标数字根本不以两数之和的形式存在于数组中，于是返回0和0，表示没组合到。

注意，这里是组合，不是排列，如果在代码中写的是排列的话，虽然对结果没影响，但是程序要花更多无用功，浪费了电脑资源。比如，如果使用排列的方式的话，以上过程在代码中就会变成：1+4！=7，1+2！=7，1+3！=7，4+1！=7，4+2！=7，4+3==7。足足多用了一次判断！不要看这里只有一次，当数组变大之后，冗余的判断会呈倍数增长。因此为了避免这种浪费，我们使用组合。

---

代码展示

package advance.algorithm;

public class SumOfTwo {
	public int sum = 0; 

	public int[] twoSum(int[] arr,int target) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				this.sum = arr[i] + arr[j];//尝试两数组合
				if (this.sum == target) {
					int[] result={i,j};
					return result;//返回这两个数的索引
				}
			}
		}return new int[] {0,0};//配对失败的返回值
	}
	//测试
	public static void main(String[] args) {
		SumOfTwo obj=new SumOfTwo();
		int[] arr = { 1, 3, 5, 7 };//原始数组
		int[] R=obj.twoSum(arr,12);
		for(int e:R)//循环打印数组R里的元素
			System.out.print(String.format("index %d; ", e));
	}
}

代码讲解

我们说说如何才能让程序执行“组合”而不是排列。在上段代码中，我们看到内嵌的for循环中，循环变量j范围是从i+1到arr.length。我们这次用上段代码中的数组arr={1,3,5,7}作例子。我们的目标数字是12。

如果循环变量j的范围是从0到arr.length，那么这就是排列。过程是这样的：arr[0]+arr[1]!=12, arr[0]+arr[2]!=12, arr[0]+arr[3]!=12, arr[1]+arr[0]!=12, arr[1]+arr[1]!=12, arr[1]+arr[2]!=12, arr[1]+arr[3]!=12, arr[2]+arr[0]!=12, arr[2]+arr[1]!=12, arr[2]+arr[2]!=12, arr[2]+arr[3]==12。

足足有五次冗余！不过如果按照范围从i+1-arr.length的话，就没有这五个冗余判断，大大节省了计算机算力。

---

寻找单个元素实现思路

这个算法是什么呢？这个算法可以在一个数组中寻找到落单的数。比如这里有数组{4，1，4，6，1}，显然，这里落单的数是6，因此该算法最后返回值为6

这里提供了两种实现思路，第一种比较代码量比较大，但是结构很稳固。第二种你没有听错，只有一行！这是纯数学思路，通过异或的特性来完成计算。

思路一

我们试着理解第一种思路。首先我们把数组里面的元素从小到大依次排列，这样相同的数字就会紧挨在一起。于是我们基本的想法就有了：如果两个相邻的数字相等，计数器就加1，表示他不是一个落单的数字。如果两个数不相等，我们就先看计数器是否为0，如果为0，就说明这个数是落单的数，我们返回它就好了；如果不为0，说明这个数的上个数和他相等，因此我们就把计数器重置为0，开始下一个计数。

我们用上面数组演示一下这个思路。在数组从小到大排序后，数组变成了：arr={1，1，4，4，6}。arr[0]==arr[1], cnt+=1; arr[1]!=arr[2], cnt!=0, so cnt=0. arr[2]==arr[3], cnt+=1; arr[3]!=arr[4], cnt!=0, so cnt=0。

这里我们遇到了一个小问题。arr[4]之后就没有元素了，无法继续进行比较。因此，我们要考虑另外一种情况，即落单的数字在数组末尾的情况。我们设立一个判断，如果一个数不等于他的下一个数，且下一个数处在数组的最大索引，那我们就直接返回下一个数，不需要再去进行下一次比较。

当然另还有一种情况。如果数组中只有一个元素，我们就无法使用上述方法，所以我们要在这个方法之前新建一个判断：如果数组长度等于1，那么就直接返回数组中唯一的元素。

思路二

我们现在看一下第二种方法，异或逻辑运算(exclusive or)。什么是异或呢？那我们要先了解一下与其相关的逻辑运算符，他们是：和(and)，或(or)以及非(not)，都属于布尔代数的范畴，也就是说我们接下来的演示用到的是二进制数。我们用1表示True，0表示False。

和：1 and 1=1, 1 and 0=0, 0 and 0=0 

或：1 or 1=1, 1 or 0=1, 0 or 0=0

非：not 1=0, not 0=1（一元运算符)

异或：1 xor 1=0, 1 xor 0=1, 0 xor 0= 0

异或也叫半加运算，它和或逻辑运算符比较相似，不过就如他的英文名一样，只有在一个1（True）一个0（False）的情况下才会返回1（True），其他情况都返回0（False）。

很多读者到这里可能就不太理解：数组中的数都是十进制的啊，这个是True和False，好像八竿子打不着关系呢。true和false可以表示为1，0，他们可以表示所有二进制数，而二进制数又能转化成十进制数，所以异或处理的数的类型并不重要，因为他们可以互相转换，同理，我们也可以使用代数来演示逻辑运算。我们现在来看一下异或满足的运算律。

交换律：a xor b= b xor a

归零律：a xor a=0

恒等律：a xor 0=a

结合律：a xor (b xor c)= (a xor b) xor c

自反律：a xor b xor a=b（可以根据交换律，归零律和恒等律推出）

其实对于以上运算律大家可以自己代数进去，都是可以成立的。利用以上运算律，我们就可以弄懂那一行代码了。我们还是拿数组{4，1，4，6，1}做例子。根据自反律，我们知道前面三个元素异或运算的结果是1，那么我们再作一次自反，这样我们就得到6。当然，这些运算律只是便于我们人类计算和理解而已，计算机实际上不会用这些，它就是一个一个数去老老实实地去算。

---

代码展示

package advance.algorithm;

import java.util.Arrays;

public class SingleNumber {
	public static int solution1(int[] arr) {//more robust than solution2 but much more complicated
		Arrays.sort(arr);
		int len=arr.length;
		if(len==1)
			return arr[0];
		int cnt=0;
		for(int i=0;i<len;i++) {
			if (arr[i]==arr[i+1]) 
				cnt++;
			else if(arr[i]!=arr[i+1]) {
				if(cnt==0) {
					return arr[i];
				}else if(i+1==len-1) {
					return arr[i+1];
				}else {
					cnt=0;
				}
			}
		}return 0;
	}

	public static int solution2(int[] arr) {
		int single=0;for(int e:arr)single^=e;return single;
	}
	
	public static void main(String[] args) {
		int[] arr= {2,2,1,4,4,1,5};
		System.out.println(solution1(arr));
		//System.out.print(solution2(arr));
	}
}