二叉树的遍历——前序、中序，后序，层次遍历以及相关题解

结点类型

struct TreeNode {
 int val;
 TreeNode *left;  //左子
 TreeNode *right;  //右孩子
 TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 };

1. 前序遍历（preorder traversal）

1. 思想：访问根结点；前序遍历左子树;前序遍历右子树
2. 代码：

void preOrder(TreeNode* proot)  //先序遍历
	{
		if ( proot == NULL) return;
		cout<<proot->val<<endl;
		preOrder(proot->left);
		preOrder(proot->right);
	}

2. 中序遍历（inorder traversal）

1. 思想：中序遍历左子树;访问根结点;中序遍历右子树。
2. 代码

 void inOrder( TreeNode* proot) //中序遍历
	{
		if ( proot == NULL) return;
		inOrder(proot->left);
		cout<<proot->val<<endl;
		inOrder(proot->right);
	}

3. 后序遍历（postorder traversal）

1. 思想：后序遍历左子树;后序遍历右子树;访问根结点
2. 代码

void postOrder(TreeNode* proot) //后序遍历
	{
		if ( proot == NULL) return;
		postOrder(proot->left);
		postOrder(proot->right);
		cout<<proot->val<<endl;
	}

4. 层次遍历

1. 思想：按从上到下，从左到右的顺序依次打印结点。
2. 代码：

void LevelOrderTranverse( TreeNode* proot)//层次遍历
	{
		if (!proot) return;
		queue<TreeNode*> que;
		que.push(proot);
		TreeNode* curr;
		while (!que.empty())
		{
			curr = que.front();
			que.pop();
			if (curr->left()) que.push(curr->left);
			if (curr->right()) que.push(curr->right);
			cout<<curr->val<<endl;
		}
	}

5. 区别

6. 根据前序遍历中序遍历重构二叉树

6.1 解法一

算法思想

由前序遍历知道根节点之后，能在中序遍历上划分出左子树和右子树。分别对中序遍历的左右子树递归进行这一过程即可建树。

代码

  TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int len=vin.size();
        if(len==0)  return nullptr;
        vector<int> pre_left,pre_right,vin_left,vin_right;
        TreeNode *head=new TreeNode(pre[0]);  //创建根节点，根节点是前序遍历的第一个数
        int gen;
        for(int i=0;i<len;i++){  //找到中序遍历根节点所在位置,存放于变量gen中
            if(vin[i]==pre[0]){
                gen=i;
                break;
            }
        }
        //左子树
        for(int i=0;i<gen;i++){
            vin_left.push_back(vin[i]);
            pre_left.push_back(pre[i+1]); //先序的第一个为根节点
        }
        //右子树
        for(int i=gen+1;i<len;i++){
            vin_right.push_back(vin[i]);
            pre_right.push_back(pre[i]); 
        }
        //递归，执行上述步骤，区分子树的左、右子子树，直到叶节点
       head->left=reConstructBinaryTree(pre_left,vin_left);
       head->right=reConstructBinaryTree(pre_right,vin_right);
       return head;
    }

时间复杂度分析

时间复杂度： T(n)=2T(n/2)+O(n)，求解地O(nlogn)。

6.2 解法二

和解法一思想相同，只不过更简洁。

代码

class Solution {
public:
    TreeNode* rebuild(vector<int>& pre, int pre_left, int pre_right, vector<int>& vin, int vin_left, int vin_right) {
        if (pre_left > pre_right||vin_left > vin_right) return nullptr;

        TreeNode* root = new TreeNode(pre[pre_left]);
        for (int i=vin_left; i<=vin_right; ++i) {
            if (vin[i] == root->val) {
                root->left = rebuild(pre, pre_left+1, pre_left+i-vin_left, vin, vin_left, i-1);
                root->right = rebuild(pre, pre_left+i-vin_left+1, pre_right, vin, i+1, vin_right);
                break;
            }
        }
        return root;
    }
    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
        return rebuild(pre, 0, pre.size()-1, vin, 0, vin.size()-1);
    }
};