OJ104：二叉树的最大深度 

1.题目 

2.注意

这里要用left和right接收递归的结果，如果不接收，直接用递归来比较，会出现效率问题。

3.参考代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int maxDepth(struct TreeNode* root) {
    if (root == NULL)
        return 0;

    int left = maxDepth(root->left) + 1;
    int right = maxDepth(root->right) + 1;

    return left > right ? left : right; 
}

OJ144：二叉树的前序遍历 

1.题目

 2.思路

        该题目要求返回的数组需要malloc，写一个求二叉树节点个数的函数。

preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root->left) 来遍历 root 节点的左子树，最后递归调用 preorder(root->right) 来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点。

3.参考代码 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct TreeNode TreeNode;
void prevorder(struct TreeNode* root,int * arr,int* pi)
{
    if(root == NULL)
    {
        return;
    }
    arr[*pi] = root->val;
    (*pi)++;
    prevorder(root->left,arr,pi);
    prevorder(root->right,arr,pi); 
}

int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    *returnSize = TreeSize(root);
    int* arr = malloc(sizeof(int)*(*returnSize));
    int i = 0;
    prevorder(root,arr,&i);
    return arr;
}

OJ965：单值二叉树 

1.题目 

2.思路 ：深度优先搜索

一棵树的所有节点都有相同的值，当且仅当对于树上的每一条边的两个端点，它们都有相同的值（这样根据传递性，所有节点都有相同的值）。

因此，我们可以对树进行一次深度优先搜索。当搜索到节点 x 时，我们检查 x 与 x 的每一个子节点之间的边是否满足要求。例如对于左子节点而言，如果其存在并且值与 x 相同，那么我们继续向下搜索该左子节点；如果值与 x 不同，那么我们直接返回 False。

3.参考代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)
        return true;

    if(root->left)
    {//深度遍历左子树   (！false)——>左子树中存在不同的数
        if(root->val != root->left->val || !isUnivalTree(root->left))
        return false;
    }
    
    if(root->right)
    {//深度遍历右子树
        if(root->val != root->right->val || !isUnivalTree(root->right))
        return false;
    }

    return true;
}

OJ100：相同的树

1.题目

2.思路

深度优先遍历：

如果两个二叉树都为空，则两个二叉树相同。如果两个二叉树中有且只有一个为空，则两个二叉树一定不相同。

如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。这是一个递归的过程，因此可以使用深度优先搜索，递归地判断两个二叉树是否相同。

3.参考代码： 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //两个都是空
    if(q == NULL && p == NULL)
        return true;

    //其中一个为空，但另外一个不是空的情况
    if(q == NULL || p == NULL)
        return false;

    if(q->val != p->val)
    {
        return false;
    }
    return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}

OJ101：对称二叉树 

1.题目

2.思路

深度优先遍历

与上一题类似，写一个子函数，分别传根节点的左右孩子。

3.参考代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool _isSymmetric(struct TreeNode*q,struct TreeNode* p)
{
    if(p == NULL && q == NULL)
        return true;
    if(p == NULL || q == NULL)
        return false;
    if(p->val != q->val)
        return false;
    return _isSymmetric(q->left,p->right) && _isSymmetric(q->right,p->left);     
}
bool isSymmetric(struct TreeNode* root) {
  if(root == NULL)
    return true;
    return _isSymmetric(root->left,root->right);
}

OJ572：另一颗树的子树

1.题目

2.思路

深度优先遍历（暴力搜索）

枚举 root 中的每一个节点，判断这个点的子树是否和subRoot 相等。如何判断一个节点的子树是否和 root 相等呢，我们又需要做一次深度优先搜索来检查，即让两个指针一开始先指向该节点和 subRoot 的根，然后同步移动两根指针来同步遍历这两棵树，判断对应位置是否相等。

3.参考代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
//判断这个点的子树是否和subRoot相等
bool check(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(subRoot == NULL && root == NULL)
        return true;

    if( (root == NULL && subRoot != NULL)|| (root != NULL && subRoot == NULL) ||(root->val != subRoot->val))
    {
        return false;
    }
    return check(root->left,subRoot->left) && check(root->right,subRoot->right);
}
//深度优先遍历(暴力匹配)
bool DFS(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root == NULL)
        return false;
    //让两个指针一开始先指向该节点和 subRoot 的根，然后同步移动两根指针来同步遍历这两棵树，判断对应位置是否相等。
    return check(root,subRoot) || DFS(root->left,subRoot) || DFS(root->right,subRoot);
}

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    return DFS(root,subRoot);   
}

OJ KY11：二叉树遍历

1.题目

2.思路

上一篇文章中介绍过的通过前序遍历数组构建二叉树方法，注意，在传数组下标时要传指针，因为局部变量出了作用域就会销毁。

3.参考代码

#include <stdio.h>

typedef struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
}TreeNode;

TreeNode* CreatTree(char* arr, int* pi)
{
    if(arr[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = arr[*pi];
    (*pi)++;
    node->left = CreatTree(arr,pi);
    node->right =CreatTree(arr,pi);
    return node;
}

void InOrder(TreeNode* root)
{
    if(root == NULL)
        return;
    InOrder(root->left);
    printf("%c ",root->val);
    InOrder(root->right);
}

int main() {
    char arr[100];
    scanf("%s",arr);
    int i = 0;
    TreeNode* root =  CreatTree(arr,&i);
    InOrder(root);
    return 0;
}