TWO SUM问题汇总

一，

给定一个整数数组，返回这两个数字的索引，使它们合计成一个特定的目标。

每个输入都只有一个解决方案，并且您不会使用相同的元素两次。

例：

给定nums = [2,7,11,15]，目标= 9，

由于nums [ 0 ] + nums [ 1 ] = 2 + 7 = 9，
返回[ 0，1 ]。

public int[] twoSum(int[] nums, int target) {
        int[] a=new int[2];
        for(int i=0;i<nums.length-1;i++) {
        	if(i>0&&nums[i]==nums[i-1])
        		continue;
        	for(int j=i+1;j<nums.length;j++) {
        		if(nums[i]+nums[j]==target) {
        			a[0]=i;a[1]=j;
        			return a;
        		}
        	}
        }
        return null;
    }

遍历了所有的可能形式，时间复杂度为O(N^2)

我们可以运用哈希表以空间换取时间

public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
	    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	    for (int i = 0; i < nums.length; i++) {
	        if (map.containsKey(target - nums[i])) {
	            result[1] = i;
	            result[0] = map.get(target - nums[i]);
	            return result;
	        }
	        map.put(nums[i], i );
	    }
	    return result;
    }

此时时间复杂度为O(N)

二，

给定已按升序排序的整数数组，找到两个数字，使它们合计为特定的目标数字。

函数twoSum应该返回这两个数字的索引，以便它们合计到目标，其中index1必须小于index2。请注意，您返回的答案（index1和index2）不是从零开始的。

每个输入都只有一个解决方案，并且您不会使用相同的元素两次。

输入：数字= { 2,7,11,15 }，目标= 9 

输出：索引1 = 1，索引2 = 2

当然可以使用哈希表实现时间复杂度为O(N)的程序。但是基于给定已按升序排序的整数数组，可以实现不使用哈希表节省空间的方法。程序的流程是：首先，在数组头尾start，end各取一个数，比较两者之和，如果和偏大则截去头端，增加start；如果和偏小，则截去尾部，减小end，如此往复，直至相等为止。

 public int[] twoSum(int[] numbers, int target) {
        int[] a=new int[2];
        int start=0,end=numbers.length-1;
        while(end>start) {
        	int sum=numbers[start]+numbers[end];
        	if(sum>target) {
        		int last=numbers[end];
        		while(end>start&&numbers[--end]==last);
        	}else if(sum<target) {
        		int first=numbers[start];
        		while(end>start&&numbers[++start]==first);
        	}else if(sum==target) {
        		a[0]=start+1;
        		a[1]=end+1;
        		return a;
        	}
        }
        return null;
    }

三，

给定一个二叉树和一个目标编号，如果BST中存在两个元素，则它们的和等于给定目标，则返回true。

例1：

输入： 
    5
   / \
  3   6
 / \   \
2   4   7

目标= 9

输出：真

例2：

输入： 
    5
   / \
  3   6
 / \   \
2   4   7

目标= 28

输出：错误

可以将先序遍历（中序遍历，后序遍历都行）和哈希表结合一起实现程序

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private boolean flag=false;
    private Set<Integer> set=new HashSet<>();
    public boolean findTarget(TreeNode root, int k) {
            if(root!=null&&!flag) {
                findTarget(root.left, k);
                findTarget(root.right, k);
                if(set.contains(k-root.val)) {
                    flag=true;
                }
                set.add(root.val);
            }
            return flag;
}
}