【剑指offer】面试题之二叉树系列（一）

1、把二叉树打印成多行

题目描述： 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行

思路：
层序遍历
问题：怎样去确定它的每一层有多少结点

按层次输出二叉树
访问根节点，并将根节点入队。
当队列不空的时候，重复以下操作。
1、弹出一个元素。作为当前的根节点。
2、如果根节点有左孩子，访问左孩子，并将左孩子入队。
3、如果根节点有右孩子，访问右孩子，并将右孩子入队。

struct TreeNode {
      int val;
      struct TreeNode *left;
      struct TreeNode *right;
      TreeNode(int x) :
      val(x), left(NULL), right(NULL)
      {}
};
// 一个队列
class Solution {
public:
      vector<vector<int> > Print(TreeNode* pRoot)
      {
            // 相当于二维数组
            vector<vector<int> > V;
            if (pRoot == NULL)
                  return V;
            //定义出一个队列 （先进先出）
            queue<TreeNode*> q;
            q.push(pRoot);    // 先把根节点放进去
            // 队列不空时
            while (!q.empty())
            {
                  //
                  int i = 0;             // 遍历的层结点的大小   ？？？  层计数
                  int size = q.size();   //队列的大小
                  vector<int> tmp;       // 数组
                  while (i++ < size)     //条件： 层结点还未遍历完时
                  {
                        TreeNode *pNode = q.front();    // 把队列里面的元素给pNode
                        q.pop();                        //pop一下
                        tmp.push_back(pNode->val);     // 把PNode里面的值给刚定义出来的存放的数组

                        // 如果根节点有左孩子，访问左孩子，并将左孩子入队。
                        if (pNode->left)
                              q.push(pNode->left);
                        // 如果根节点有右孩子，访问右孩子，并将右孩子入队。
                        if (pNode->right)
                              q.push(pNode->right);
                  }
                  V.push_back(tmp);
            }
            return V;
      }
};

2、二叉树的镜像

题目描述：
操作给定的二叉树，将其变换为源二叉树的镜像
分析：
（1）递归写法：先序遍历树的每个结点，若遍历到的结点有子节点，则交换它的两个子节点
（2）非递归：借助栈去存放结点；（先序遍历）

//  二叉树的镜像
#include<iostream>
using namespace std;
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 (NULL == pRoot)
                  return;
            if (NULL == pRoot->left && NULL == pRoot->right)
                  return;
            // 交换左右结点
            TreeNode* pNode = pRoot->left;
            pRoot->left = pRoot->right;
            pRoot->right = pNode;
            // 递归一下左右子树
            if (NULL != pRoot->left)
                  Mirror(pRoot->left);
            if (NULL != pRoot->right)
                  Mirror(pRoot->right);
      }
};
// 非递归
#include<stack>
class Solution {
public:
      void Mirror(TreeNode *pRoot)
      {
            // 判断树是否存在
            if (NULL == pRoot)
                  return;
            // 借助栈来存放结点
            stack<TreeNode*> s;
            s.push(pRoot);
            // 当栈里面存在元素，不为空时
            while (!s.empty())
            {
                  TreeNode* pRoot = s.top();
                  s.pop();
                  if (NULL != pRoot->left || NULL != pRoot->right)
                  {
                        TreeNode* pCur = pRoot->left;
                        pRoot->left = pRoot->right;
                        pRoot->right = pCur;
                  }
                  if (NULL != pRoot->left)
                        s.push(pRoot->left);
                  if (NULL != pRoot->right)
                        s.push(pRoot->right);
            }
      }
};

3、二叉树的深度

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

// 二叉树的深度
#include<iostream>
using namespace std;
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)
      {
            // 判断树是否存在
            if (NULL == pRoot)
                  return 0;
            int leftcount = 1;
            int rightcount = 1;
            leftcount += TreeDepth(pRoot->left);
            rightcount += TreeDepth(pRoot->right);
            return leftcount > rightcount ? leftcount : rightcount;
      }
};

// 非递归，借助队列
#include<queue>
class Solution {
public:
      int TreeDepth(TreeNode* pRoot) {
            if (NULL == pRoot)
                  return 0;

            // 定义一个队列(先进先出)，让pRoot进队列
            queue<TreeNode*> q;
            q.push(pRoot);

            int depthcount = 0;   // 深度

            while (!q.empty())
            {
                  int size = q.size();
                  depthcount++;
                  for (int i = 0; i<size; i++)
                  {     
                        //一次处理一层的数据
                        TreeNode *pNode = q.front();
                        q.pop();
                        if (pNode->left)
                              q.push(pNode->left);
                        if (pNode->right)
                              q.push(pNode->right);
                  }
            }
            return depthcount;
      }
};