力扣算法题

一、简单题

1.两数之和

思路：本题要使用map，使用数组和set来做哈希法有局限。数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下表位置，因为要返回x 和 y的下表。所以set 也不能用。此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下表。

代码：

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

2.回文数

思路：把整数转为可以利用索引的形式：整数转换为字符串，使用String.chatAt()。第一个数与最后一个数比较，第二个数与倒数第二个数比较。如果跳出循环，则判断是否比较完，没有比较完就跳出for，说明不是回文数

代码：

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) return false;
        String s = String.valueOf(x);
        int len = s.length();
        int i;
        for (i = 0; i <= len / 2; i++) {
            if (s.charAt(i) != s.charAt(len - i - 1)) {
                break;
            }
        }
        if (i < len / 2) {
            return false;
        } else {
            return true;
        }
    }
}

3.搜索插入位置

思路：本题利用二分法查找即可

代码：

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int low = 0;
        int high = n - 1;

        while (low <= high) { 
            int mid = low + (high - low) / 2;
            if (nums[mid] > target) {
                high = mid - 1; 
            } else if (nums[mid] < target) {
                low = mid + 1; 
            } else {
                return mid;
            }
        }
        return high + 1;
    }
}

二、中等题

1.无重复字符的最长子串

思路：可以用map记录每个字符上一次出现的位置，也可以用set加while循环记录。对于s[i], 上一次出现位置如果在start之后，就更新start，否则不需要。

代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size() == 0) return 0;
        unordered_map<char, int> occ;
        int start=0, len=0;
        for(int i = 0; i < s.size(); i++) {
            if(occ.find(s[i]) != occ.end() && occ[s[i]] >= start) {
                start = occ[s[i]]+1;
            }
            len = max(len, (i-start+1));
            occ[s[i]] = i;
        }
        return len;
    }
};

2.盛最多水的容器

思路：这里用到了动态规划，基本的表达式: area = min(height[i], height[j]) * (j - i) 使用两个指针，值小的指针向内移动，这样就减小了搜索空间，因为面积取决于指针的距离与值小的值乘积，如果值大的值向内移动，距离一定减小，而求面积的另外一个乘数一定小于等于值小的值，因此面积一定减小，而我们要求最大的面积，因此值大的指针不动，而值小的指针向内移动遍历。

代码：

class Solution {
public:
    int maxArea(vector<int>& height) {
        if(height.size() <= 1) return -1;
        int i = 0, j = height.size() - 1, res = 0;
        while(i < j){
            int h = min(height[i], height[j]);
            res = max(res, h * (j - i));
            if(height[i] < height[j]) ++i;
            else --j;
        }
        return res;
    }
};