D&C

原题：https://leetcode.com/problems/valid-anagram/
思路：Anagram就是指两个单词（一说句子也行）里面字符的种类、数量一样，但是能拼出不同的词。所以思路就是统计里面的字符频率就行。
代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size() != t.size())
            return false;
        int stable[26] = {0};
        int ttable[26] = {0};
        for(int i=0; i<s.size(); i++){
            stable[s[i] - 'a'] ++;
            ttable[t[i] - 'a'] ++;
        }
        for(int i=0; i<26; i++){
            if (stable[i] != ttable[i])
                return false;
        }
        return true;
    }
};

题目：https://leetcode.com/problems/move-zeroes/
思路：
说是把0 挪到后面去，其实等同于把非0值往前挪。挪到什么地方呢？就得找个东西记录可以往前挪的“坑”。而这个“坑”有两种情况：
1.原来的值就是0的；
2.如果把当前的非0值往前面挪过了，那当前的位置也就空缺；
从一开始记录一下找到的0的个数，把非0值挪完了以后，最后几位写成0就行。
这一切的时间复杂度为O(n)
代码（用到了队列来存储坑的位置）：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int size = nums.size();
        int zeroCount = 0;
        queue<int> availIndices;
        for(int i=0; i < size; i++){
            if(nums[i] == 0){
                zeroCount ++;
                availIndices.push(i);
            } else {
                if(!availIndices.empty()) {
                    //Move forward
                    int index =availIndices.front();
                    availIndices.pop();
                    nums[index] = nums[i];
                    //Mark i as empty
                    availIndices.push(i);
                }
            }
        }
        for(int i = size - zeroCount; i < size; i++) {
            nums[i] = 0;
        }
    }
};

题目：https://leetcode.com/problems/same-tree/
分析：注意判断NULL情况，用递归做
代码：（秒AC有木有！）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == NULL && q == NULL)
            return true;
        if(p == NULL || q == NULL)
            return false;
        if(p->val != q->val)
            return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

题目：https://leetcode.com/problems/invert-binary-tree/
思路：这TM还要思路？
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL)
            return root;
        TreeNode *tmpNode = root->right;
        root->right = root->left;
        root->left = tmpNode;
        if(root->left != NULL)
            invertTree(root->left);
        if(root->right != NULL)
            invertTree(root->right);
        return root;
    }
};