leetcode：两数之和

力扣1：

给定一个升序排列的整数数组 numbers ，从数组中找出两个数满足相加之和等于目标数 target 。

假设每个输入只对应唯一的答案，而且不可以重复使用相同的元素。

返回两数的下标值，以数组形式返回

package com.lz;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class sum {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Arrays.toString(solution(new int[] {1,2,3,4,5,6},10)));
		System.out.println(Arrays.toString(solution1(new int[] {1,2,3,4,5,6},10)));
		System.out.println(Arrays.toString(twoSearch(new int[] {1,2,3,4,5,6},10)));
		System.out.println(Arrays.toString(twoPoint(new int[] {1,2,3,4,5,6},10)));
	}

	//暴力解法
	public static int[] solution(int[] nums,int target) {
		for(int i=0;i<nums.length;i++) {
			for(int j=i+1;j<nums.length;j++) {
				if(nums[i]+nums[j]==target) {
					return new int[] {i,j};
				}
			}
		}
		return new int[] {0};
	}
	
	//哈希表：将数组的值作为key存入map，target - num作为key
	public static int[] solution1(int[] nums,int target) {
		Map<Integer,Integer> map=new HashMap<Integer,Integer>();
		for(int i=0;i<nums.length;i++) {
			if(map.containsKey(target-nums[i])) {
				return new int[] {map.get(target-nums[i]),i};
			}
			map.put(nums[i],i);
		}
		return new int[] {0};
	}
	
	//二分查找
	public static int[] twoSearch(int[] nums,int target) {
		for(int i=0;i<nums.length;i++) {
			int low=i,high=nums.length-1;
			while(low<=high) {
				int mid=low+(high-low)/2;
				if(nums[mid]==target-nums[i]) {
					return new int[] {i,mid};
				}else if(nums[mid]>target-nums[i]) {
					high=mid-1;
				}else {
					low=mid+1;
				}
			}
		}
		return new int[] {0};
	}
	
	//双指针
	public static int[] twoPoint(int[] nums,int target) {
		int low=0,high=nums.length-1;
		while(low<high) {
			int sum=nums[low]+nums[high];
			if(sum==target) {
				return new int[] {low,high};
			}else if(sum>target) {
				high--;
			}else {
				low++;
			}
		}
		return new int[] {0};
	}
	
	
}

另：

package com.lz.forth;
 
import java.util.HashMap;
import java.util.Map;
 
public class TwoSum {
 
 
    public static void main(String[] args) {
        int[] nums={4,6,13,8,7,9,1};
        int[] result=new TwoSum().fastWithMap(nums,20);
        for(int e:result){
            System.out.print(nums[e]+" ");
        }
        System.out.println();
        int[] nums2={3,2,4};
        int[] result2=new TwoSum().fastWithMap2(nums2,6);
        for(int e:result2){
            System.out.print(nums2[e]+" ");
        }
    }
 
	
    /*暴力穷举，复杂度O(n^2)*/
    public int[] normal(int[] nums,int target) {
        int[] result=new int[2];
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target) {
                    result[0]=i;
                    result[1]=j;
                    return result;
                }
            }
        }
        return result;
    }
 
    /*用一个哈希表，存储每个数对应的下标,时间复杂度是O(n)*/
    public int[] fastWithMap(int[] nums,int target) {
        /*key为元素值，value为每个元素对应的下标*/
        Map<Integer,Integer> storeNums=new HashMap<>();
        int[] result=new int[2];
        for(int i=0;i<nums.length;i++){
            int another=target-nums[i];
            Integer anotherIndex=storeNums.get(another);
            if(anotherIndex!=null){
                result[0]=anotherIndex ;
                result[1]=i;
                break;
            }else{
                storeNums.put(nums[i],i);
            }
        }
        return result;
    }
 
    /*用一个哈希表，存储每个数对应的下标,时间复杂度是O(n)*/
    public int[] fastWithMap2(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<>();
        int[] result=new int[2];
        for (int i=0;i<nums.length;i++) {
            if(map.containsKey(nums[i])) {
                int anotherIndex=map.get(nums[i]);
                result[0]=anotherIndex ;
                result[1]=i;
                break;
            }else {
                map.put(target-nums[i],i);
            }
        }
        return result;
    }
 
}