Letcode-Top 100 简单题目

1. 两数之和

1.这道题目首先想到的是用暴力破解的方法

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        // 循环
        for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return result;

    }
}

2.HashMap方法（本思路为，先将数组遍历存储到Map中，然后，在每次遍历查询的时候去掉自身的数据，这里需要注意的地方是，map.remove(key)是根据key删除，map.remover(key,value)）是根据键值对删除。可能存在{3,3}这样的数据，所以删除的话，要用map.remove(key,value)，否则，用map.remove(key)的话，会删除两个值。

/*使用存储空间  */
import java.util.Map;
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        
        // 结果
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],i);
        }

        for(int i=0;i<nums.length;i++){
            map.remove(nums[i],i);

            if(map.containsKey(target-nums[i])){
                return new int[]{i,map.get(target-nums[i])};
            }
            map.put(nums[i],i);

        }

        return result;

    }
}

3.HashMap的优化方法 （Letcode官方解法，先查询后放到Map中）

/*使用存储空间  */
import java.util.Map;
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        
        // 结果
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int[]{i,map.get(target-nums[i])};
            }
            map.put(nums[i],i);

        }

        return result;

    }
}

20. 有效的括号

• 这道题的核心思路是把逻辑梳理清楚

由于栈结构的特殊性，非常适合做对称匹配类的题目。
首先要弄清楚，字符串里的括号不匹配有几种情况。
一些同学，在面试中看到这种题目上来就开始写代码，然后就越写越乱。
建议要写代码之前要分析好有哪几种不匹配的情况，如果不动手之前分析好，写出的代码也会有很多问题。
先来分析一下 这里有三种不匹配的情况，
第一种情况，字符串里左方向的括号多余了 ，所以不匹配。 !括号匹配1
第二种情况，括号没有多余，但是 括号的类型没有匹配上。 !括号匹配2
第三种情况，字符串里右方向的括号多余了，所以不匹配。 !括号匹配3
我们的代码只要覆盖了这三种不匹配的情况，就不会出问题，可以看出 动手之前分析好题目的重要性。

动画如下：

1.常规逻辑

import java.util.Stack;
class Solution {
    public boolean isValid(String s) {

        // 首先对字符串进行拆分 
        char[] chars = s.toCharArray();
        Stack<Character> stack = new Stack<>();

        for(int i=0;i<chars.length;i++){
            if(chars[i]=='('||chars[i]=='{'||chars[i]=='['){
                 stack.push(chars[i]);
            }else{
                if(stack.isEmpty()||(!isMatch(stack.peek(),chars[i]))){
                    return false;
                }
                stack.pop();
            }
        }

        if(stack.isEmpty()){
            return true;
        }else{
            return false;
        }

    }


    public boolean isMatch(char left,char right){
        if(left=='('&&right==')'){return true;}
        if(left=='{'&&right=='}'){return true;}
        if(left=='['&&right==']'){return true;}
        return false;
    }
}

2.Letcode经典逻辑

import java.util.Stack;
class Solution {
    public boolean isValid(String s) {

        // 首先对字符串进行拆分 
        char[] chars = s.toCharArray();
        Stack<Character> stack = new Stack<>();

        for(int i=0;i<chars.length;i++){
            if(chars[i]=='('){
                stack.push(')');
            }else if(chars[i]=='{'){
                stack.push('}');
            }else if(chars[i]=='['){
                stack.push(']');
            }else {
                if(stack.isEmpty()){
                    return false;
                }
                if(stack.peek()==chars[i]){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }

        if(!stack.isEmpty()){
           return false;
        }

       return true;

    }

}