二叉树经典题目（1）

二叉树前序遍历

链接: https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

/**
 * 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().
 */
int size(struct TreeNode* t)
{
    if(t == NULL)
        return 0;
    else
        return size(t->left) + size(t->right) + 1;
}
void _preorderTraversal(struct TreeNode* root, int* preorder_array, int* i)
{
    if(root != NULL)
    {
        preorder_array[*i] = root->val;
        (*i)++;
        _preorderTraversal(root->left, preorder_array,i);
        _preorderTraversal(root->right, preorder_array,i);
    }
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    int n = size(root);
    int* preorder_array = (int*)malloc(sizeof(int) * n);
    *returnSize = n;

    int index = 0;
    _preorderTraversal(root, preorder_array,&index);
    return preorder_array;
}

二叉树中序遍历

链接: https://leetcode-cn.com/problems/binary-tree-inorder-traversal/submissions/.

/**
 * 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().
 */
 int size(struct TreeNode *t)
{
    if(t == NULL)
        return 0;
    else
        return size(t->left) + size(t->right) + 1;
}

void _InorderTraversal(struct TreeNode *root, int *Inorder_array, int *i)
{
    if(root != NULL)
    {
        _InorderTraversal(root->left, Inorder_array, i);
        Inorder_array[*i] = root->val;
        (*i)++;
        _InorderTraversal(root->right, Inorder_array, i);
    }
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    int n = size(root); 
    int *Inorder_array = (int*)malloc(sizeof(int) * n);
    *returnSize = n;

    int index = 0;
    _InorderTraversal(root, Inorder_array, &index);

    return Inorder_array;
}

二叉树后序遍历

链接: https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

同上前序中序，这里也采用递归算法、

/**
 * 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().
 */
int size(struct TreeNode *t)
{
    if(t == NULL)
        return 0;
    else
        return size(t->left) + size(t->right) + 1;
}

void _postorderTraversal(struct TreeNode *root, int *postorder_array, int *i)
{
    if(root != NULL)
    {
        _postorderTraversal(root->left, postorder_array, i);
        _postorderTraversal(root->right, postorder_array, i);
                 
        postorder_array[*i] = root->val;
        (*i)++;
    }
}

int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    int n = size(root);
    int *postorder_array = (int*)malloc(sizeof(int) * n);
    *returnSize = n;

    int index = 0;
    _postorderTraversal(root, postorder_array, &index);
    return postorder_array;
}

二叉树是否相等

链接: https://leetcode-cn.com/problems/same-tree/

/**
 * 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(p == NULL && q == NULL)
        return true;
    if(p == NULL || q == NULL)
        return false;
    return p->val == q->val && isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}

另一颗树的子树

链接: https://leetcode-cn.com/problems/subtree-of-another-tree/

/**
 * 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 (p == NULL && q == NULL)
		return true;
	if (p == NULL || q == NULL)
		return false;

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

bool isSubtree(struct TreeNode* s, struct TreeNode* t)
{
    if(t == NULL)
        return true;
    if(s == NULL)
        return false;
    if(isSameTree(s,t))
        return true;
    return isSubtree(s->left,t) || isSubtree(s->right,t);
}

二叉树的最大深度

链接: https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

/**
 * 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_h = maxDepth(root->left);
    int right_h = maxDepth(root->right);
    return (left_h > right_h ? left_h : right_h) + 1;
}

平衡二叉树

链接: https://leetcode-cn.com/problems/balanced-binary-tree/

/**
 * 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_h = maxDepth(root->left);
    int right_h = maxDepth(root->right);
    return (left_h>right_h ? left_h : right_h) + 1;
}

bool isBalanced(struct TreeNode* root)
{
    if(root == NULL)
        return true;
    int left_h = maxDepth(root->left);
    int right_h = maxDepth(root->right);
    return abs(left_h - right_h) < 2 && isBalanced(root->left) && isBalanced(root->right);
}

对称二叉树

链接: https://leetcode-cn.com/problems/symmetric-tree/

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

bool isSymmetric(struct TreeNode* root)
{
    if(root == NULL)
        return true;
    return _isSymmetric(root->left, root->right);
}

二叉树的创建及遍历

链接: https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&tqId=29483&rp=1&ru=%2Factivity%2Foj&qru=%2Fta%2Ftsing-kaoyan%2Fquestion-ranking&tab=answerKey.

#include<stdio.h>
#include<assert.h>

typedef struct BinTreeNode
{
    char data;
    struct BinTreeNode* left;
    struct BinTreeNode* right;
}BinTreeNode;

typedef BinTreeNode* BinTree;


BinTree CreatBinTree(const char *str, int* i)
{
    if(str[*i] == '#' || str[*i] == '\0')
        return NULL;
    BinTreeNode* t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
    assert(t != NULL);
    t->data = str[*i];
    (*i)++;
    t->left = CreatBinTree(str,i);
    (*i)++;
    t->right =CreatBinTree(str,i);
    return t;
}

void InOrder(BinTree t)
{
    if(t != NULL)
    {
        InOrder(t->left);
        printf("%c ", t->data);
        InOrder(t->right);
    }
}

void DestroyBinTree(BinTree* t)
{
    if(*t != NULL)
    {
        DestroyBinTree(&((*t)->left));
        DestroyBinTree(&((*t)->right));
        free(*t);
        *t = NULL;
    }
}
int main()
{
    BinTree bt = NULL;
    char arr[100] = {0};
    while(scanf("%s", arr) != EOF)
    {
        int index = 0;
        bt = CreatBinTree(arr, &index);
        InOrder(bt);
        printf("\n");
        DestroyBinTree(&bt);
    }
    return 0;
}