LeetCode Top100 Liked Questions

1. TwoSum

　　https://www.cnblogs.com/zhacai/p/10429120.html  easy

2. Add Two Numbers

　　https://www.cnblogs.com/zhacai/p/10429155.html  easy

15.3Sum

　　https://www.cnblogs.com/zhacai/p/10579514.html medium set

20.Valid Parentheses

　　https://www.cnblogs.com/zhacai/p/10429168.html  easy

21.Merge Two Sorted Lists

　　https://www.cnblogs.com/zhacai/p/10429234.html  easy　　

22.Generate Parentheses

　　https://www.cnblogs.com/zhacai/p/10599156.html medium DFS 剪枝

49.Group Anagrams

　　https://www.cnblogs.com/zhacai/p/10576638.html medium 哈希 map

53.Maximum Subarray　

　　https://www.cnblogs.com/zhacai/p/10429247.html  easy

70.Climbing Stairs

　　https://www.cnblogs.com/zhacai/p/10429253.html  easy

72.Edit Distance

　　https://www.cnblogs.com/zhacai/p/10661858.html hard dp

79.Word Search

　　https://www.cnblogs.com/zhacai/p/10641454.html medium DFS

94. Binary Tree Inorder Traversal

　　https://www.cnblogs.com/zhacai/p/10435799.html  medium 树的中序遍历<递归><迭代（栈）>

98.Validate Binary Search Tree

　　https://www.cnblogs.com/zhacai/p/10592337.html medium 二叉搜索树 中序遍历 递归

102.Binary Tree Level Order Traversal

　　https://www.cnblogs.com/zhacai/p/10598674.html medium 树 BFS

104.Maxinum Depth of Binary Tree　　

　　https://www.cnblogs.com/zhacai/p/10429258.html  easy 树DFS

121. Best Time to Buy and Sell Stock

　　https://www.cnblogs.com/zhacai/p/10429264.html  easy

136. Single Number　　

　　https://www.cnblogs.com/zhacai/p/10429270.html  easy

141. Linked List Cycle

　　https://www.cnblogs.com/zhacai/p/10560803.html easy 链表 快慢指针

142. Linked List Cycle II 

　　https://www.cnblogs.com/zhacai/p/10561152.html medium 链表 快慢指针

146. LRU Cache

　　https://www.cnblogs.com/zhacai/p/10665121.html hard LRUCache linkedHashMap hashmap+双向链表

152. Maximum Product Subarray

　　https://www.cnblogs.com/zhacai/p/10644095.html medium dp

155. Min Stack

　　https://www.cnblogs.com/zhacai/p/10429280.html  easy

169.Majority Element

　　https://www.cnblogs.com/zhacai/p/10429286.html  easy

200.Number of Islands

　　https://www.cnblogs.com/zhacai/p/10662241.html medium dfs 并查集

206.ReverseLinked List

　　https://www.cnblogs.com/zhacai/p/10429295.html  easy 链表

208.Implement Trie(Prefix Tree)

　　https://www.cnblogs.com/zhacai/p/10640769.html medium 字典树

226.Invert Binary Tree　　

　　https://www.cnblogs.com/zhacai/p/10431018.html  easy 树 递归

236.Lowest Common Ancestor of a Binary Tree

　　https://www.cnblogs.com/zhacai/p/10592779.html medium 树 递归

239.Sliding Window Maximum

　　https://www.cnblogs.com/zhacai/p/10567783.html  hard 双向队列 大顶堆

283.Move Zeroes

　　https://www.cnblogs.com/zhacai/p/10431000.html  easy

300.Longest Increasing Subsequence

　　https://www.cnblogs.com/zhacai/p/10661330.html medium dp

309.Best Time to Buy and Sell Stock with Cooldown

　　https://www.cnblogs.com/zhacai/p/10655970.html medium dp

322.Coin Change

　　https://www.cnblogs.com/zhacai/p/10661489.html medium dp

338. Counting Bits

　　https://www.cnblogs.com/zhacai/p/10430986.html  easy  位运算 找规律

347. Top K Frequent Elements(待完善)

　　https://www.cnblogs.com/zhacai/p/10436261.html  medium 排序 map

438.Find All Anagrams in a String

　　https://www.cnblogs.com/zhacai/p/10596274.html  easy 滑动窗口 map

448. Find All Numbers Disappeared in an Array

Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once. Find all the elements of [1, n] inclusive that do not appear in this array. Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

Example:

Input:
[4,3,2,7,8,2,3,1]

Output:
[5,6]

public List<Integer> findDisappearedNumbers(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int x = nums[i]<0?-nums[i]:nums[i];
            if(nums[x-1]>0){
                nums[x-1]= -nums[x-1];
            }
        }
        List<Integer> re = new ArrayList<Integer>();
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]>0){
                re.add(i+1);
            }
        }
        return re;
    }

　　　　

461.Hamming Distance　　

The Hamming distance between two integers is the number of positions at which the corresponding bits are different.Given two integers x and y, calculate the Hamming distance.

Note:0 ≤ x, y < 2³¹.

Example:

Input: x = 1, y = 4

Output: 2

Explanation:
1   (0 0 0 1)
4   (0 1 0 0)
       ↑   ↑

The above arrows point to positions where the corresponding bits are different.

public int hammingDistance(int x, int y) {//位运算
        int n = x^y;
        int re = 0;
        //计算整数二进制中1的个数
        while(0!=n){
            n=n&(n-1);
            re++;
        }
        return re;
    }

538.Convert BST to Greater Tree

Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.

Example:

Input: The root of a Binary Search Tree like this:
              5
            /   \
           2     13

Output: The root of a Greater Tree like this:
             18
            /   \
          20     13

class Solution {
    int sum=0;
    public TreeNode convertBST(TreeNode root) {//树
        if(null!=root){
            TreeNode right = convertBST(root.right);
            root.val+=sum;
            sum = root.val;
            TreeNode left = convertBST(root.left);
        }
        return root;
    }
}

　　

543.Diameter of Binary Tree

Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.

Example:
Given a binary tree

          1
         / \
        2   3
       / \
      4   5    

Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].

Note: The length of path between two nodes is represented by the number of edges between them.

class Solution {
    int re;
    public int diameterOfBinaryTree(TreeNode root) {//树的深度 递归
        re =0;
        maxDepth(root);
        return re;
    }
    public int maxDepth(TreeNode root) {
        if(null==root){
            return 0;
        }
        int ld=maxDepth(root.left);
        int lr = maxDepth(root.right);
        int d = ld>lr?(ld+1):(lr+1);
        re =re>(ld+lr)?re:(ld+lr);
        return d;
    }
}

　　

617.Merge Two Binary Trees

Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.

Example 1:

Input:
	Tree 1                     Tree 2
          1                         2
         / \                       / \
        3   2                     1   3
       /                           \   \
      5                             4   7
Output:
Merged tree:
	     3
	    / \
	   4   5
	  / \   \
	 5   4   7

Note: The merging process must start from the root nodes of both trees.

public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {//树 递归
        if(null==t1&&null==t2){
            return null;
        }
        if(null==t1){
            return t2;
        }
        if(null==t2){
            return t1;
        }
        TreeNode left=mergeTrees(t1.left,t2.left);
        TreeNode right = mergeTrees(t1.right,t2.right);
        TreeNode node = new TreeNode(t1.val+t2.val);
        node.left=left;
        node.right=right;
        return node;
    }　　

简洁写法

public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null)
            return t2;
        if (t2 == null)
            return t1;
        t1.val += t2.val;
        t1.left = mergeTrees(t1.left, t2.left);
        t1.right = mergeTrees(t1.right, t2.right);
        return t1;
    }　　

非递归方法

public class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null)
            return t2;
        Stack < TreeNode[] > stack = new Stack < > ();
        stack.push(new TreeNode[] {t1, t2});
        while (!stack.isEmpty()) {
            TreeNode[] t = stack.pop();
            if (t[0] == null || t[1] == null) {
                continue;
            }
            t[0].val += t[1].val;
            if (t[0].left == null) {
                t[0].left = t[1].left;
            } else {
                stack.push(new TreeNode[] {t[0].left, t[1].left});
            }
            if (t[0].right == null) {
                t[0].right = t[1].right;
            } else {
                stack.push(new TreeNode[] {t[0].right, t[1].right});
            }
        }
        return t1;
    }
}

　　

771. Jewels and Stones

　　https://www.cnblogs.com/zhacai/p/10429670.html  easy　　

　　

　　

7.Reverse Integer　　

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output: 321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹,  231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

public int reverse(int x) {
       String str= String.valueOf(x);
        StringBuffer strb;
        int re=0;
        if('-'==str.charAt(0)){
            strb = new StringBuffer(str.substring(1,str.length())).reverse();
            strb.insert(0,"-");
        }
        else {
            strb= new StringBuffer(str).reverse();
        }
        try{
            re =Integer.valueOf(strb.toString());
        }catch (Exception e){

        }
        return re;
    }　　

使用数学方法的优解

public int reverse(int x) {
       int re = 0;
        while(0!=x){
            int temp = re * 10 + x % 10;
            if(temp / 10 != re)//如果整数不溢出显然相等
                return 0;
            re = temp;
            x /= 10;
        }
        return re;
    }