我们都知道，已知前序和中序的序列是可以唯一确定一个二叉树的。

初始化时候二叉树为：==================

前序遍历序列，           O=================

中序遍历序列，           ======O===========

红色部分是左子树，黑色部分是右子树，O是根节点

如上图所示，O是根节点，由前序遍历可知，

根据这个O可以把找到其在中序遍历当中的位置，进而，知道当前这个根节点O的左子树的前序遍历和中序遍历序列的范围。

以及右子树的前序遍历和中序遍历序列的范围。

到这里返现出现了重复的子问题，而且子问题的规模没有原先的问题大，即红色部分和黑色部分。

而联系这两个子问题和原先的大问题的纽带是这个找到的根节点。

可以选择用递归来解决这个问题，递归的结束条件是子问题序列里面只有一个元素。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

给定一个二叉树的前序和中序遍历序列，构造这个二叉树。

笔记：

你可以假定，这棵树里面没有重复的节点。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
test.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
  
#include <iostream>
#include <cstdio>
#include <stack>
#include <vector>
#include "BinaryTree.h"

using namespace std;

/**
 * Definition for binary tree
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
TreeNode *build(vector<int> &preorder, int left1, int right1, vector<int> &inorder, int left2, int right2)
{
    //对错误输入的判断
    if(right1 - left1 != right2 - left2)
    {
        return NULL;
    }
    if(right1 >= preorder.size() || right2 >= inorder.size())
    {
        return NULL;
    }

if(left1 == right1 && left2 == right2)
    {
        //只有一个节点的情况
        TreeNode *root = new TreeNode(preorder[left1]);
        return root;
    }
    else if(left1 < right1 && left2 < right2)
    {
        //多个节点的情况，生成当前的根节点
        TreeNode *root = new TreeNode(preorder[left1]);
        int i;
        for(i = left2; i <= right2; i++)
        {
            //找到中序的当前根节点的位置
            if(inorder[i] == preorder[left1])
            {
                break;
            }
        }
        if(i > right2)
        {
            return NULL;
        }
        /*
         * 递归的构建左边二叉树的和右边的二叉树
         * 左子树{left1 + 1, i - 1}                   前序[left1 + 1, left1 + i - left2]           中序[left2, i - 1]
         * 右子树{left1 + i - left2 +1, right2}       前序[left1 + i - left2 + 1, right1]          中序[i + 1, right2]
         * 前序以left1 + i - left2为分割点
         * 中序以i为分割点
         */
        root->left = build(preorder, left1 + 1, left1 + i - left2, inorder, left2, i - 1);
        root->right = build(preorder, left1 + i - left2 + 1, right1, inorder, i + 1, right2);
        return root;
    }
    else
    {
        return NULL;
    }

}

TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
{
    return build(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
}

vector<vector<int> > levelOrder(TreeNode *root)
{

vector<vector<int> > matrix;
    if(root == NULL)
    {
        return matrix;
    }
    vector<int> temp;
    temp.push_back(root->val);
    matrix.push_back(temp);

vector<TreeNode *> path;
    path.push_back(root);

int count = 1;
    while(!path.empty())
    {
        TreeNode *tn = path.front();
        if(tn->left)
        {
            path.push_back(tn->left);
        }
        if(tn->right)
        {
            path.push_back(tn->right);
        }
        path.erase(path.begin());
        count--;

if(count == 0)
        {
            vector<int> tmp;
            vector<TreeNode *>::iterator it = path.begin();
            for(; it != path.end(); ++it)
            {
                tmp.push_back((*it)->val);
            }
            if(tmp.size() > 0)
            {
                matrix.push_back(tmp);
            }
            count = path.size();
        }
    }
    return matrix;
}

// 树中结点含有分叉，
//                  6
//              /       \
//             7         2
//           /   \
//          1     4
//               / \
//              3   5
int main()
{
    TreeNode *pNodeA1 = CreateBinaryTreeNode(6);
    TreeNode *pNodeA2 = CreateBinaryTreeNode(7);
    TreeNode *pNodeA3 = CreateBinaryTreeNode(2);
    TreeNode *pNodeA4 = CreateBinaryTreeNode(1);
    TreeNode *pNodeA5 = CreateBinaryTreeNode(4);
    TreeNode *pNodeA6 = CreateBinaryTreeNode(3);
    TreeNode *pNodeA7 = CreateBinaryTreeNode(5);

ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);
    ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);
    ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);

int pre[7] = {6, 7, 1, 4, 3, 5, 2};
    int in[7] = {1, 7, 3, 4, 5, 6, 2};
    vector<int> preorder(pre, pre + 7), inorder(in, in + 7);

TreeNode *root = buildTree(preorder, inorder);

vector<vector<int> > ans = levelOrder(root);

for (int i = 0; i < ans.size(); ++i)
    {
        for (int j = 0; j < ans[i].size(); ++j)
        {
            cout << ans[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    DestroyTree(root);
    return 0;
}

 
结果输出：
6

7 2

1 4

3 5

ps.利用的是层次遍历测试的输出结果。
BinaryTree.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  
#ifndef _BINARY_TREE_H_
#define _BINARY_TREE_H_

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode *CreateBinaryTreeNode(int value);
void ConnectTreeNodes(TreeNode *pParent,
                      TreeNode *pLeft, TreeNode *pRight);
void PrintTreeNode(TreeNode *pNode);
void PrintTree(TreeNode *pRoot);
void DestroyTree(TreeNode *pRoot);

#endif /*_BINARY_TREE_H_*/
BinaryTree.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
  
#include <iostream>
#include <cstdio>
#include "BinaryTree.h"

using namespace std;

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

//创建结点
TreeNode *CreateBinaryTreeNode(int value)
{
    TreeNode *pNode = new TreeNode(value);

return pNode;
}

//连接结点
void ConnectTreeNodes(TreeNode *pParent, TreeNode *pLeft, TreeNode *pRight)
{
    if(pParent != NULL)
    {
        pParent->left = pLeft;
        pParent->right = pRight;
    }
}

//打印节点内容以及左右子结点内容
void PrintTreeNode(TreeNode *pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %d\n", pNode->val);

if(pNode->left != NULL)
            printf("value of its left child is: %d.\n", pNode->left->val);
        else
            printf("left child is null.\n");

if(pNode->right != NULL)
            printf("value of its right child is: %d.\n", pNode->right->val);
        else
            printf("right child is null.\n");
    }
    else
    {
        printf("this node is null.\n");
    }

printf("\n");
}

//前序遍历递归方法打印结点内容
void PrintTree(TreeNode *pRoot)
{
    PrintTreeNode(pRoot);

if(pRoot != NULL)
    {
        if(pRoot->left != NULL)
            PrintTree(pRoot->left);

if(pRoot->right != NULL)
            PrintTree(pRoot->right);
    }
}

void DestroyTree(TreeNode *pRoot)
{
    if(pRoot != NULL)
    {
        TreeNode *pLeft = pRoot->left;
        TreeNode *pRight = pRoot->right;

delete pRoot;
        pRoot = NULL;

DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}
 
 
												


											
【构建二叉树】01根据前序和中序序列构造二叉树【Construct Binary Tree from Preorder and Inorder Traversal】的更多相关文章
	

    
								
  1. [LeetCode] Construct Binary Tree from Preorder and Inorder Traversal  由先序和中序遍历建立二叉树
		
    Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume that  ...
    
		
    2. 
						
  2. [LeetCode] 105. Construct Binary Tree from Preorder and Inorder Traversal 由先序和中序遍历建立二叉树
		
    Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume that  ...
    
		
    3. 
						
  3. [Swift]LeetCode105. 从前序与中序遍历序列构造二叉树 | Construct Binary Tree from Preorder and Inorder Traversal
		
    Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume that  ...
    
		
    4. 
						
  4. LeetCode105 从前序和中序序列构造二叉树
		
    题目描述: 根据一棵树的前序遍历与中序遍历构造二叉树. 注意:你可以假设树中没有重复的元素. 例如,给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9 ...
    
		
    5. 
						
  5. LeetCode 105. Construct Binary Tree from Preorder and Inorder Traversal 由前序和中序遍历建立二叉树 C++
		
    Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume that  ...
    
		
    6. 
						
  6. LeetCode 105. 从前序与中序遍历序列构造二叉树（Construct Binary Tree from Preorder and Inorder Traversal）
		
    题目描述 根据一棵树的前序遍历与中序遍历构造二叉树. 注意:你可以假设树中没有重复的元素. 例如,给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9, ...
    
		
    7. 
						
  7. Leetcode105. Construct Binary Tree from Preorder and Inorder Traversal前序与中序构造二叉树
		
    根据一棵树的前序遍历与中序遍历构造二叉树. 注意: 你可以假设树中没有重复的元素. 例如,给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15 ...
    
		
    8. 
						
  8. leetcode题解:Construct Binary Tree from Preorder and Inorder Traversal (根据前序和中序遍历构造二叉树)
		
    题目: Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume t ...
    
		
    9. 
						
  9. LeetCode OJ：Construct Binary Tree from Preorder and Inorder Traversal（从前序以及中序遍历结果中构造二叉树）
		
    Given preorder and inorder traversal of a tree, construct the binary tree. Note:You may assume that  ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. 一站式WPF--依赖属性（DependencyProperty）
			
    2009-10-20 11:32 by 周永恒, 22441 阅读, 24 评论, 收藏, 编辑 书接上文,前篇文章介绍了依赖属性的原理和实现了一个简单的DependencyProperty(DP), ...
    
			
    2. 
						
  2. python爬虫学习研究
			
    目标:做一个小爬虫项目 2017年6月4日13:32:17       mooc网教程Python爬虫入门一之综述要学习Python爬虫,我们要学习的共有以下几点:Python基础知识Python中u ...
    
			
    3. 
						
  3. （转）linux设备驱动之USB数据传输分析 一
			
    三:传输过程的实现说到传输过程,我们必须要从URB开始说起,这个结构的就好比是网络子系统中的skb,好比是I/O中的bio.USB系统的信息传输就是打成URB结构,然后再过行传送的.URB的全称叫US ...
    
			
    4. 
						
  4. vue router-link子级返回父级页面
			
    vue-router嵌套路由,从二级路由跳转到一级路由时,间歇性导致一级路由重叠 解决方法: 1.使用this.$router.push跳转
    
			
    5. 
						
  5. MySQL 数据库事物隔离级别的设置
			
    select @@tx_isolation; //查看隔离级别 set session transaction isolation level read uncommitted; //设置读未提交级别 ...
    
			
    6. 
						
  6. 九度OJ 1198：a+b （大数运算）
			
    时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:6745 解决:2320 题目描述: 实现一个加法器,使其能够输出a+b的值. 输入: 输入包括两个数a和b,其中a和b的位数不超过1000位 ...
    
			
    7. 
						
  7. Webpack探索【5】--- plugins详解
			
    本文主要讲plugins相关内容. https://gitbook.cn/gitchat/column/59e065f64f7fbe555e479204/topic/59e96d87a35cf44e1 ...
    
			
    8. 
						
  8. Difference Between ZIP and GZIP
			
    From: http://www.differencebetween.net/technology/difference-between-zip-and-gzip/ Summary: 1. GZIP  ...
    
			
    9. 
						
  9. eclipse js调试
			
    问题: js经常会被浏览器给cache,不管怎么刷都是原来的. 解决: 暂时有一个方法,一刷新就好,下面的截图: 1)先打开 <开发者工具> 2)找到Sources 3)Page中找到你的 ...
    
			
    10. 
						
  10. FOXMAIL提示容量满无法收邮件，清除旧邮件后还是无法收取，请问如何解决？
			
    FOXMAIL提示容量满无法收邮件,清除旧邮件后还是无法收取,请问如何解决? 2009-03-23 11:21包子燕  分类:网站使用 我清除了FOXMAIL所在的磁盘空间,共有12G,也删除了部分旧 ...
    
			
    11.