Leetcode解题思路

简单题

所有简单题的解题思路。

#204 Count Primes

Question： Count the number of prime numbers less than a non-negative number,n
Example:

Input: 10
Output: 4
Explanation: There are 4 prime numbers less than 10,
there are 2, 3, 5, 7
时间复杂度小于 O(n^2)

对于如何判断一个数是否是质数，我们可以遍历2到n-1，只要不出现整除即可判断是质数。初步思路：

int countPrimes(int n) {
    int count = 0;
    for (int i = 2; i < n; i++)
        if (isPrim(i)) count++;
    return count;
}

// 判断整数 n 是否是素数
bool isPrime(int n) {
    for (int i = 2; i < n; i++)
        if (n % i == 0)
            // 有其他整除因子
            return false;
    return true;
}

优化代码，我们可以对for (int i = 2; i < n; i++) 进行简化， 判断i * i<n即可，因为两数相乘不会超过n的话，临界点就是开方。for(int i = 2; i * i < n ; i++) 。
高效算法
我们发现对于质数2，只要是2的倍数4、6、8、10…等都不是质数。
质数3，3的倍数6、9、12等等。
在这里我们先初始化n个bool数组，用来判断是否是质数，以便最后计数用。之后我们遍历数组，只要当前是质数，我们将它的倍数bool数组对应的位置变成false，即它们不是素数。最后我们计算bool数组的True的个数就是质数个数。

int countPrimes(int n) {
		//初始化bool数组，初始化都为质数，下一步排除质数。
        vector<bool> num(n, 1);
        for(int i = 2 ;i*i<n;i++) {
        	//当前是质数，将其倍数对应的位置变成false
            if(num[i])  {
                for(int j = 2*i; j<=n; j+=i) {
                    num[j] = false;
                }
            }
        }
        int count = 0;
        for(int i = 2; i<n; i++) {
            if(num[i])  count++;
        }
        return count;
 }

接下来我们看动图展示：

图片来自 wikimedia

我们继续优化代码，我们发现对于2的倍数，2、4、6、8。4的倍数4、8、16。会发现有重复出现。
我们可以修改一下j，让j从i的平方开始遍历。这样就可以优化相应的时间。最后代码如下

int countPrimes(int n) {
        vector<bool> num(n, 1);
        for(int i = 2 ;i*i<n;i++) {
            if(num[i])  {
                for(int j = i*i; j<=n; j+=i) {
                    num[j] = false;
                }
            }
        }
        int count = 0;
        for(int i = 2; i<n; i++) {
            if(num[i])  count++;
        }
        return count;
    }

#226 Invert Binary Tree

Question: Invert a binary tree
Example:
Input:

     4
   /   \
  2     7
 / \   / \
1   3 6   9

Output:

     4
   /   \
  7     2
 / \   / \
9   6 3   1

递归反转二叉树，经典代码：

void helper(TreeNode * root) {
        if(!root)   return;
        TreeNode * temp = root->left;
        root->left = root->right;
        root->right = temp;
        helper(root->left);
        helper(root->right);
    }


    TreeNode* invertTree(TreeNode* root) {
        helper(root);
        return root;
    }

#235Lowest Common Ancestor of a Binary Search Tree

**Question：**给一个二叉搜索树，找出所给q，p对应值的最近公共父母。
Example：

	 6
   /   \
  2     8
 / \   / \
0   4 7   9
   / \
  3   5

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Answer:
递归算法，利用二叉搜索树的性质，左边小，右边大。当p，q的值在某个节点分叉时，则当前节点就是最近公共节点。例如2，8.在6节点分叉。再如2，4在2节点分叉。故递归满足条件

1、p，q的值一个大于当前值一个小于当前值，返回当前节点
2、如果都小于当前值，则往左子树走，如果都大于则往右子树走。

代码如下：

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
       if(!root)    return root;
       if(root->val >= p->val && root->val<=q->val || root->val <=p->val && root->val >=q->val) return root;
       else if(p->val > root->val && q->val>root->val)   return lowestCommonAncestor(root->right, p,q);
       return lowestCommonAncestor(root->left, p,q);
    }