一,
给定一个整数数组,返回这两个数字的索引,使它们合计成一个特定的目标。
每个输入都只有一个解决方案,并且您不会使用相同的元素两次。
例:
给定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;
}
}