数据结构——二叉树经典OJ题

1.单值二叉树

单值二叉树：就是判断二叉树里的所有值是否都一样

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

    //查找有没有左子树并且看左子树当前指向的值是否和根当前指向的值相等
     if(root -> left && root -> left -> val != root -> val)
     return false;

     //查找有没有右子树并且看右子树当前指向的值是否和根当前指向的值相等
     if(root -> right && root -> right -> val != root -> val)
     return false;

    //如果上面的左右子树有一个false就不会执行另一个
     return isUnivalTree(root -> left) && isUnivalTree(root -> right);
}

---

2. 相同的树（isSameTree）

isSame:用于比较两个值是否相同的函数

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的

 //isSame:用于比较两个值是否相同的函数
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. 对称二叉树（isSymmetric ）

也称之为镜像二叉树，就是从中间对折之后是相同的

思路：1.先判断两棵树的结构和值是否相同

            2.再判断左子树的左值和右子树的右值是否相同

            3.最后判断左子树的右值和右子树的左值是否相同

bool compare(struct TreeNode *left,struct TreeNode *right)
{
    if(left==NULL && right==NULL)
        return true;

    if(left==NULL || right ==NULL)
        return false;

    if(left->val != right->val)
        return false;
        
    return compare(left->left,right->right) &&
           compare(left->right,right->left);
}

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

---

 4. 另一棵树的子树

就是判断一棵树是不是另一棵树的子树

 

提示：

    1. root 树上的节点数量范围是 [1, 2000]

    2. subRoot 树上的节点数量范围是 [1, 1000]

    3. -104 <= root.val <= 104

    4. -104 <= subRoot.val <= 104

思路

1. 判断一棵二叉树是否为另一棵二叉树的子树：

                                a. 两树相等为子树。

                                b. 递归地判断左右子树是否存在相等的树

2.判断两棵二叉树是否相等：

                                a. 两棵树根节点都为空则相等

                                b. 递归地判断左右子树是否全都相等

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
      	// 如果两个树相同，返回 true
        if (isSameTree(root, subRoot)) return true;
        // 如果根节点是空的，说明没有子树
        if (root == null) return false;
        // 否则递归检查左子树和右子树
        return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }

    private boolean isSameTree(TreeNode s, TreeNode t) {
        // 如果两个根节点都为空，则相同
        if (s == null && t == null) return true;
        // 如果只有一个为空，则不同
        if (s == null || t == null) return false;
        // 如果值不同，也不相同
        if (s.val != t.val) return false;
        // 递归检查左子树和右子树是否相同
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}

---

5. 二叉树销毁

// 二叉树销毁
void TreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}

---

6.层序遍历

层序遍历：简单点来说呢，就是将其数据一层一层的进行遍历打印

层序遍历需要与队列的代码结合来一起实现

利用其先进先出的特性并结合二叉树实现层序遍历

先遍历二叉树的所有节点，每遍历一个节点的时候就先把数据打印出来，再将其删除，然后再把左右孩子节点传入队列中并继续递归调用

核心思想就是：上一层带下一层

说明一下：我们在队列中存储的并不是数值，而是二叉树节点的地址。所以在删除数据之后，二叉树的节点并不会消失

void TreeLevelOrder(root) {
	Queue pq;
	QueueInit(&pq);//创建一个队列
 
//判断二叉树是否是空树。不是空树就将根节点入队列
	if (root) 
       {
		    QueuePush(&pq, root);
	   }
 

//判断栈是否为空队列，不为空的话就可以进入程序中循环
	while (!QueueEmpty(&pq)) 
        {
         //先取根节点的地址
		BTNode* front = QueueFront(&pq);

		//将根节点弹出队列
		QueuePop(&pq);
 
		printf("%d ", front->data);
		
        //判断根节点的左子树是否存在
		if (front->left) 
            {
                //如果存在则将其入队列
			    QueuePush(&pq, front->left);
		    }
 
        //判断根节点的右子树是否存在
		if (front->right)
             {
                //如果存在，则将其入队列
			    QueuePush(&pq, front->right);
		    }
    	}    
 
	        printf("\n");

	        QueueDestory(&pq);
}

---

                                                               完结撒花~