LeetCode算法题1

LeetCode1——Two Sum(Easy)

Description

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

方法一：O(n²)+双重循环——44ms

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] a=new int[2];
        int count=nums.length,temp,flag=0;
        for(int i=0;i<count-1;i++){
            for(int j=i+1;j<count;j++){
                temp=nums[i]+nums[j];
                if(temp==target){
                    a[0]=i;
                    a[1]=j;
                    flag=1;
                    break;
                }
                if(flag==1)
                    break;
            }
        }
        return a;
    }
}

最常见最简单的方法，但耗时久(44ms)，时间复杂度为O(n²)。

方法二：O(n)+HashMap——8ms

用到了java中的HashMap

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

注：
1.HshMap中的key和value不能使用原始数据类型，只能使用JAVA提供的封装类。

原始数据类型	封装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

2.仅从代码来看，算法时间复杂度为O(n)，但事实上并非如此，JAVA中HashMap的实现是借助于红黑树的，因此算法复杂度并非简单的O(n）。

方法三：O(nlogn)——5ms

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] num=Arrays.copyOf(nums,nums.length);
        Arrays.sort(num);
        int[] result=new int[2];
        int start=0,end=nums.length-1;
        int temp,a=0,b=0,i,j;
        while(start<end)
        {
            temp=num[start]+num[end];
            if(temp<target)
                start++;
            else if(temp>target)
                end--;
            else
            {
                a=num[start];
                b=num[end];
                break;
            }
        }
        for(i=0;i<nums.length;i++)
        {
            if(nums[i]==a)
            {
                result[0]=i;
                break;
            }
        }
        if(a==b)
        {
            for(j=0;j<nums.length;j++)
            {
                if(nums[j]==b&&i!=j)
                {
                    result[1]=j;
                    break;
                }
            }
        }
        else
        {
           for(j=0;j<nums.length;j++)
            {
                if(nums[j]==b)
                {
                    result[1]=j;
                    break;
                }
            } 
        }       
        return result; 
    }
}

时间复杂度不好确定。
java中的Arrays.sort()方法，在数组元素>7时采用快速排序，时间复杂度在O(nlogn)~O(n²)之间；在数组元素<=7时采用插入排序，时间复杂度为O(n²)。