LeetCode日记3

（2015/11/3）

LeetCode-36 Valid Sudoku：（easy）

1）使用数据结构

set<char> emptyset;

vector<set<char>> mp(27, emptyset);

2）下标0-8存储行中的数字，9-17存储列中的数字，18-26存储3×3块中数字。

3）双重for循环中，i表示行，9 + j表示列，18 + i / 3 + 3 * (j / 3)表示块。

---

（2015/11/12）

LeetCode-38 Count and Say：（easy）

1）判断参数n，返回直接输出的部分。

2）双重for循环。

LeetCode-58 Length of Last Word：（easy）

LeetCode-66 Plus One：（easy）

LeetCode-67 Add Binary：（easy）

LeetCode-70 Climbing Stairs：（easy）

1）爬楼梯，裴波那契数列。

2）公式F(1)=1, F(2)=2,........F(n)=F(n-1)+F(n-2)。

LeetCode-83 Remove Duplicates from Sorted List：（easy）

1）删除已排序的链表中的重复节点。

2）处理输入为空链表的状况。

3）使用两个指针，一个记录上一个节点，一个寻找下一个不一样的节点。找到就作指针的变换（不管变换先后是否真的改变了指针）。

LeetCode-88 Merge Sorted Array：（easy）

1）题目理解：m和n是数组中已经初始化的元素。也就是说数组的大小可能比m和n大，且数组中可能有未初始化的元素。

LeetCode-100 Same Tree：（easy）

1）错误思路：分别计算出两棵树的中序遍历和先序遍历，判断他们是否相等。

错误的例子：[1,1] 和 [1,NULL,1]

2）正确思路：同时对两棵树进行遍历。递归实现。

---

（2015/11/13）

LeetCode-101 Symmetric Tree：（cant）

1）错误思路：对树进行 ”左子树-根-右子树“和”右子树-根-左子树“遍历后序列相等，则树是对称的。（异想天开）

错误的例子：[1,2,3,3,NULL,2,NULL]

2）正确思路：同100题，必须同时向两边进行遍历。

3）参考：https://leetcode.com/discuss/26705/15-lines-of-c-solution-8-ms

递归对二叉树进行对称遍历：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        else return func(root->left, root->right);
    }
private:
    bool func(TreeNode *p, TreeNode *q){
        if(p == NULL && q == NULL) return true;
        else if(p == NULL || q == NULL) return false;
        else{
            if(p->val != q->val) return false;
            else return func(p->left, q->right) && func(p->right, q->left);
        }
    }

};

LeetCode-102 Binary Tree Level Order Traversal：（easy）

对二叉树按层遍历。

1）思路：用队列存放每一层的节点的指针。

LeetCode-104 Maximum Depth of Binary Tree：（easy）

求二叉树叶子节点的最大深度。

1）思路：形参ans存放目前叶子节点的最大深度（引用）；形参now存放当前此次遍历的当前深度。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int ans = 0;
        DFS(root, ans, 0);
        return ans;
    }
private:
    void DFS(TreeNode *T, int &ans, int now){
        if(T == NULL){
            if(now > ans) ans = now;
        }
        else{
            now++;
            DFS(T->left, ans, now);
            DFS(T->right, ans, now);
        }
        return;
    }
};

LeetCode-107 Binary Tree Level Order Traversal II：（easy）

同LeetCode-102 Binary Tree Level Order Traversal。

1）最后在返回前，对vector<vector<int>> 变量进行一次reverse函数调用便可。

LeetCode-110 Balanced Binary Tree：（easy）

a height-balanced binary tree：a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

基本概念：

1）百度百科-平衡二叉树：空树，或者它的左右两棵子树的高度差的绝对值不超过1，而且左右两棵子树也是平衡二叉树

2）树的高度（树的深度）：树中结点的最大层次。

3）结点的层次：从根开始定义起，根为第一层，根的孩子为第二层。

解题思路：

1）计算二叉树深度的子函数：

int depth(TreeNode *T){
        if(T == NULL) return 0;
        else return max(depth(T->left) + 1, depth(T->right) + 1);
    }

2）判断是不是平衡二叉树的函数（flag做为主函数中传入的标志）

    void func(TreeNode *T, bool &flag){
        if(flag == false) return;
        if(T == NULL) return;
        if(abs(depth(T->left) - depth(T->right)) > 1){
            flag = false;
            return;
        }
        else{
            func(T->left, flag);
            func(T->right, flag);
        }
    }

LeetCode-111 Minimum Depth of Binary Tree：（easy）

基本概念：

1）二叉树的minimum depth：从根到叶子结点的最短路径上，的结点数目。

2）叶子结点是左右子树都为空的结点。此题中，当只有一个根结点时，能够视根结点为叶子结点，不然不能够。

错误思路：

1）不能经过求：左右子树的树高的最小值来计算。由于求树的高度，实际上是求出了最大深度。

2）不能碰到空结点，就觉得是叶子结点。叶子结点的判断要经过左右子树。

AC代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        int mindepth = 0;
        func(root, mindepth, 0);
        return mindepth;
    }
    void func(TreeNode *T, int &mindepth, int now){
        if(T == NULL) return;
        now++;
        if(T->left == NULL && T->right == NULL){
            if(mindepth == 0) mindepth = now;
            if(now < mindepth) mindepth = now;
            return;
        }
        func(T->left, mindepth, now);
        func(T->right, mindepth, now);
        return;
    }
};

LeetCode-112 Path Sum：（easy）

1）到叶子结点进行一次判断便可。

LeetCode-118 Pascal's Triangle：（easy）

LeetCode-119 Pascal's Triangle II：（easy）（稍微修改118便可，注意这里第0层是[1]，第一层是[1,1]）

---

（2015/11/14）

LeetCode-125 Valid Palindrome：（easy）

题目理解：

回文串的判断。

1）alphanumeric characters：字母和数字字符

2）ignoring cases：例如"       "，是回文串。

C++的细节问题：

1）对string变量，从两端向中间遍历的问题。在for循环中，string的下标定义为整型变量，若定义为string::size_type，则可能会形成溢出。

LeetCode-226 Invert Binary Tree：（easy）

1）递归，一层一层向下反转便可。

LeetCode-257 Binary Tree Paths：（easy）

1）关键：判断叶子节点。

2）int转换为string。

LeetCode-235 Lowest Common Ancestor of a Binary Search Tree：（easy）（do more time）

1）递归方法

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

结点p和q的值为1，其余结点的值为0；

树的值为树上全部节点的值的和。

每一个节点的值 =  左子树的值 + 右子树的值 + 本结点的值。（递归）

2）第一个值为2的结点，就是所要找的结点。

class Solution {
public:
	TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
		bool find = false;
		TreeNode *ans;
		func(root, ans, find, p, q);
		return ans;
	}
	int func(TreeNode *T, TreeNode *&ans, bool &find, TreeNode *p, TreeNode *q){
		if (T == NULL || find) return 0;
		int val = 0;
		if (T == p) val++;
		if (T == q) val++;
		val += func(T->left, ans, find, p, q) + func(T->right, ans, find, p, q);
		if (!find && val == 2){
			ans = T;
			find = true;
		}
		return val;
	}
};

LeetCode-94 Binary Tree Inorder Traversal：（递归easy）（迭代：参考《数据结构》）

1）迭代法思路：用栈存放子树的根结点。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode *> stk;
        TreeNode *p = root;
        while(p || !stk.empty()){
            if(p){
                stk.push(p);
                p = p->left;
            }
            else{
                p = stk.top();
                stk.pop();
                ans.push_back(p->val);
                p = p->right;
            }
        }
        return ans;
    }
};