【剑指Offer】二叉树深度(队列实现BFS、递归实现DFS)、二叉树镜像 （队列实现BFS）

前言

树的遍历方式总体分为两类：深度优先搜索（DFS）、广度优先搜索（BFS）

• 常见的 DFS ： 先序遍历、中序遍历、后序遍历
• 常见的 BFS ： 层序遍历（即按层遍历）

二叉树深度

题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

广度优先搜索BFS（队列）

树的层序遍历 / 广度优先搜索往往利用 队列 实现。
关键点： 每遍历一层，则计数器 +1 ，直到遍历完成，则可得到树的深度。

• 时间复杂度 O(N) ： N 为树的节点数量，计算树的深度需要遍历所有节点。
• 空间复杂度 O(N) ： 最差情况下（当树平衡时），队列 queue 同时存储 N/2 个节点。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        int depth = 0;
        if(pRoot==NULL)
            return depth;
        queue<TreeNode*> que;
        que.push(pRoot);
        while( !que.empty() ){
            depth++;
            int num = que.size();
            for(int i=0; i<num; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left!=NULL)
                    que.push(node->left);
                if(node->right!=NULL)
                    que.push(node->right);
            }
        }
        return depth;
    }
};

深度优先搜索 dfs

树的后序遍历 / 深度优先搜索往往利用 递归 或 栈 实现
关键点： 此树的深度和其左（右）子树的深度之间的关系。显然，此树的深度 等于 左子树的深度 与 右子树的深度中的 最大值 +1 。

• 时间复杂度 O(N) ： N 为树的节点数量，计算树的深度需要遍历所有节点。
• 空间复杂度 O(N) ： 最差情况下（当树退化为链表时），递归深度可达到 N ，需要使用 O(N) 的栈空间。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if( root==NULL ){
            return 0;
        }
        return max( maxDepth(root->left), maxDepth(root->right) )+1;
    }
};

二叉树镜像

题目描述

题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/
6 10
/ \ /
5 7 9 11
镜像二叉树
8
/
10 6
/ \ /
11 9 7 5

广度优先搜索BFS（队列）

在二叉树深度的代码基础上，队列：每次顺序放入当前层的1或者2个根结点，遍历到下一层取出的时候，将各自的左右结点交换，再放入队列，循环操作

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL)
            return;
        //队列：每次顺序放入当前层的1/2个根结点，遍历到下一层取出的时候，将各自的左右结点交换，再放入队列，循环操作
        queue<TreeNode*> que;
        que.push(pRoot);
        while( !que.empty() ){
            int num = que.size();
            for(int i=0; i<num; i++ ){
                //取出一个根结点
                TreeNode* node = que.front();
                que.pop();
                //交换左右子树
                TreeNode* left = node->left;
                node->left = node->right;
                node->right = left;
                //左右结点继续压入队列，剩下子树继续交换
                if(node->left != NULL)
                    que.push(node->left);
                if(node->right != NULL)
                    que.push(node->right);
            }
        }
    }
};