二叉树基础oj练习-

二叉树
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
   
   先序、中序与后序遍历大同小异
   前序遍历结果：1 2 3 4 5 6
   中序遍历结果：3 2 1 5 4 6
   后序遍历结果：3 1 5 6 4 1

2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。

3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

题目链接

1.链接: 单值二叉树
2.链接: 相同的树
3.链接: 对称二叉树
4.链接: 二叉树的前序遍历
5.链接: 二叉树的中序遍历
6.链接: 二叉树的后序遍历

解题思路：

1.遍历二叉树，并且每一个节点值都和根节点的值进行比对，如果不等于根节点的值，则不是单值树。
2.遍历二叉树，并且一个树节点的值与另一个书的结点值进行比对，如果不等于根节点的值，则不是相同的树。
3.先分成两个树后，遍历二叉树，并且一个树节点的值与另一个书的结点值进行比对，如果不等于根节点的值，则不是相同的树，即不是对称树。

代码：

1.单值树

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

bool BTd(struct TreeNode* root, int x)
{
    if(root==NULL)
        return true;
    if(root->val != x)
        return false;

    return BTd(root->left, x) && BTd(root->right, x);

}

bool isUnivalTree(struct TreeNode* root)
{
    if(root==NULL)
        return true;
    
    int a = root->val;
    return BTd(root, a);

}

2.相同的树

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


}

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(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->right) && isSameTree(p->right, q->left);
}

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

4. 二叉树的前序遍历
提醒：数组的下标我们要传地址，这样可以保证递归的时候用的是都一个i,(例如；根的左右结点，左结点用完后i自增后，不会影响右边结点的i。)

/**
 * 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 BTSize(struct TreeNode* root)
 {
     if(root==NULL)
        return 0;
    
    return 1+BTSize(root->left)+BTSize(root->right);

 }

void preorder(struct TreeNode* root, int* a, int* pi)
{
    if(root==NULL)
        return;
    
    a[(*pi)++]=root->val;
    preorder(root->left, a, pi);
    preorder(root->right, a, pi);

}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize = BTSize(root);
    int* a=(int*)malloc(*returnSize * 4);
    
    if(a==NULL)
    {
        printf("malloc fail");
        exit(-1);
    }
    int i=0;
    preorder(root, a, &i);
    
    return a;
}

5二叉树的中序遍历

/**
 * 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 BTSize(struct TreeNode* root)
 {
     if(root==NULL)
        return 0;
    
    return 1+BTSize(root->left)+BTSize(root->right);

 }

void inorder(struct TreeNode* root, int* a, int* pi)
{
    if(root==NULL)
        return;
    
    inorder(root->left, a, pi);
     a[(*pi)++]=root->val;
    inorder(root->right, a, pi);

}

int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize=BTSize(root);
    int* a=(int*)malloc(*returnSize * 4);
    if(a==NULL)
    {
        printf("malloc fail");
        exit(-1);
    }

    int i=0;
    inorder(root, a, &i);
    
    return a;
}

6. 二叉树的后序遍历

/**
 * 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 BTSize(struct TreeNode* root)
 {
     return root==NULL?0:1+BTSize(root->left)+BTSize(root->right);
 }

 void postorder(struct TreeNode* root, int* a, int* pi)
 {
     if(root==NULL)
        return;
    
    postorder(root->left, a, pi);
    postorder(root->right, a, pi);
    a[(*pi)++]=root->val;

 }

int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    *returnSize=BTSize(root);
    int* a=(int*)malloc(*returnSize * 4);
    if(a==NULL)
    {
        printf("malloc fail");
    }

    int i=0;
    postorder(root, a, &i);


    return a;
}

感想友友们的观看。