【LeetCode】热题 HOT 100

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
链接：两数之和
（1）两重循环，暴力求解

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(target == nums[i] + nums[j]) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }
}

（2）使用HashMap
解题思路： 遍历数组，查看map中是否存在另一个值与其相加等于target，如果存在则直接返回这两个数值的下标，否则将该值放到map中。

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

2. 两数相加

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字0之外，这两个数都不会以0开头。
链接：两数相加

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = null, tail = null;
        int sum = 0, carry = 0;
        while(l1 != null || l2 != null) {
            int x = (l1 != null) ? l1.val : 0;
            int y = (l2 != null) ? l2.val : 0;
            sum = carry + x + y;
            carry = sum / 10;
            if(head == null) {
                head = new ListNode(sum % 10);
                tail = head;
            }else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
        }
        if(carry > 0) {
          tail.next = new ListNode(carry);  
        }
        return head;
    }
}

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

给定一个字符串s ，请你找出其中不含有重复字符的最长子串的长度。
链接：无重复字符的最长子串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Set<Character> set = new HashSet<>();
        int start = 0, end = 0;
        int ans = 0;
        while(start < s.length() && end < s.length()) {
            if(set.contains(s.charAt(end))) {
                set.remove(s.charAt(start));
                start ++;
            }else {
                ans = Math.max(ans, end-start+1);
                set.add(s.charAt(end));
                end ++;
            }
        }
        return ans;
    }
}

70. 爬楼梯

假设你正在爬楼梯。需要n阶你才能到达楼顶。
每次你可以爬1或2个台阶。你有多少种不同的方法可以爬到楼顶呢？
链接：爬楼梯

class Solution {
    public int climbStairs(int n) {
        int[] nums = new int[n+1];
        nums[1] = 1;
        if(n<2) return 1;
        else {
            nums[2] = 2;
            for(int i = 3; i <= n; i++) {
                nums[i] = nums[i-1] + nums[i-2];
                }
                return nums[n];
        }
    }
}

94. 二叉树的中序遍历

给定一个二叉树的根节点root，返回它的中序遍历 。
链接：二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        inorder(list, root);
        return list;
    }
    public void inorder(ArrayList<Integer> list, TreeNode root) {
        if(root == null) {
            return ;
        }else {
            inorder(list, root.left);
            list.add(root.val);
            inorder(list, root.right);
        }
    }
}