LeetCode刷题——1st

难度：简单/Easy

序号与题目：1——两数之和

给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思考：1.采用暴力破解，依次检查两个元素的和是否为目标值，若是返回他们的数组下标

           2.采用哈希表，原理是先取一段len长度的hash表，len为数组中最小的数min和符合条件的最大数max（由目标数减去最小数确定）之差。将满足条件的数组元素放入Hash表中，通过hash表中target-nums[i]-min来确定是否已经找到满足条件的下标，使用Hash法可以把时间复杂度降低到O(n)，不过在数组内值差别很大时不太适合此方法。例如数组有两个元素[-1000,1000],，分配空间就太大，效率不高。

实现：1方法：.C

int* twoSum(int* nums, int numsSize, int target) 
{  
    int *a = (int*)malloc(2*sizeof(int));  
    for(int i = 0;i<numsSize;i++)  
    {  
        for(int j = i+1;(j<numsSize && j != i);j++)  
        {  
            if(nums[i] + nums[j] == target)  
            {  
                a[0] = i;  
                a[1] = j;  
            }  
        }  
    }  
    return a;  
}  

C++

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> v(2);
        for(int i=0;i<nums.size();i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    v[0]=i;v[1]=j;
                }
            }
        }
        return v;
    }
};

Java

class Solution 
{
    public int[] twoSum(int[] nums, int target) 
    {
        for(int i = 0; i < nums.length; i++) 
        {
            for(int j = i + 1; j < nums.length; j++) 
            {
                if(nums[j] == target - nums[i]) 
                {
                return new int[] { i, j };
                }
            }
        }
    throw new IllegalArgumentException("No two sum solution");
    }
}

Python

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)): 
            a=nums[i] 
            nums2=nums[i+1:] 
            for j in range(len(nums2)): 
                b=nums2[j] 
                if a+b==target: 
                    return [i,i+j+1]

2方法：实现 C

int* twoSum(int* nums, int numsSize, int target) 
{
    int min = 2147483647;
    int i = 0;
    for (i = 0; i < numsSize; i++) 
    {
        if (nums[i] < min)
            min = nums[i];
    }
    int max = target - min;
    int len = max - min + 1;   //确定hash长度
    int *table = (int*)malloc(len*sizeof(int));
    int *indice = (int*)malloc(2*sizeof(int));
    for (i = 0; i < len; i++) 
    {
        table[i] = -1;         //hash初值
    }
    for (i = 0; i < numsSize; i++) 
    {
        if (nums[i]-min < len) {
            if (table[target-nums[i]-min] != -1) 
            {    //满足相加为target
                indice[0] = table[target-nums[i] - min];
                indice[1] = i;
                return indice;
            }
            table[nums[i]-min] = i;
        }
    }
    free(table);
    return indice;
}

C++

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        unordered_map<int, int> m;
        for (int i = 0; i < nums.size(); ++i) 
        {
            if (m.count(target - nums[i])) 
            {
                return {m[target - nums[i]],i};
            }
            m[nums[i]] = i;
        }
        return {};
    }
};

Java

class Solution {
    public int[] twoSum(int[] nums, int target) 
    {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) 
        {
            int complement = target - nums[i];
            if (map.containsKey(complement)) 
            {
                return new int[] 
                {
                    map.get(complement), i 
                };
            }
        map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

Python

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        nums_hash = {}
        for j, num in enumerate(nums):
            complement = target - num
            if complement in nums_hash:
                return [nums_hash[complement], j]
            else:
                nums_hash[num] = j

序号与题目：7——整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:在首位的0不显示
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31,  2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

思考：

int Intmax=214748368;
int sum=0,t=0,k=0;
while(x>0)
    {
        t=x%10;
        x=x/10;
        k=sum*10+t;
        sum=k;
    }
这样的方式很容易在k=sum*10+t产生溢出(因为k很容易大于2^31-1或者是小于-2^31),
所以实现要进行溢出检查，若溢出了则直接返回0
分析：如果k=sum*10+t溢出，那么有sum>=IntMax/10，如果sum>Intmax/10，那么k=sum*10+t必溢出
如果t==Intmax/10，如果t>7那么k=sum*10+t必溢出,因为极限下(2^32-1)%10=2147483647%10=7。
如果x<0，与此类似，
但是对于t==-Intmax/10,如果t<-8那么k=sum*10+t必溢出,因为极限下(-2^32)%10=-2147483648%10=-8。

实现：C

int reverse(int x) 
{
    int sum=0,t=0;
    int max=2147483647,min=-2147483648;
    while(x!=0)
    {
        t=x%10;
        x=x/10;
        if(sum>max/10||(sum==max/10&&t>7)) 
            return 0;
        if(sum<min/10||(sum==min/10&&t<-8)) 
            return 0;
        sum=sum*10+t;
    }
    return sum;
}

C++

class Solution 
{
public:
    int reverse(int x) 
    {
        int sum=0,t=0;
        int max=2147483647,min=-2147483648;
        while(x!=0)
        {
            t=x%10;
            x=x/10;
            if(sum>max/10||(sum==max/10&&t>7)) 
                return 0;
            if(sum<min/10||(sum==min/10&&t<-8)) 
                return 0;
            sum=sum*10+t;
        }
        return sum;
    }
};

Java

class Solution 
{
public int reverse(int x) 
    {
        int sum=0,t=0;
        int max=2147483647,min=-2147483648;
        while(x!=0)
        {
            t=x%10;
            x=x/10;
            if(sum>max/10||(sum==max/10&&t>7)) 
                return 0;
            if(sum<min/10||(sum==min/10&&t<-8)) 
                return 0;
            sum=sum*10+t;
        }
        return sum;
    }
};

Python

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        overflow_pos=pow(2,31)-1
        overflow_neg=float(-pow(2,31))
        rev=0
        while x!=0:
            trunc=int(float(x)/10)
            pop=x-trunc*10
            x=trunc
            if rev > overflow_pos/10 or (rev==overflow_pos//10 and pop > 7): return 0
            if rev < overflow_neg/10 or (rev==int(overflow_neg/10) and pop < -8): return 0
            rev=rev*10+pop
        return rev