200202题（前序、中序构建二叉树，中序、后序构建二叉树）

最新推荐文章于 2022-09-12 08:52:15 发布

ShenHang_

最新推荐文章于 2022-09-12 08:52:15 发布

阅读量320

点赞数

分类专栏： DFS

本文链接：https://blog.csdn.net/ShenHang_/article/details/104122347

版权

DFS 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

在这里插入图片描述
自己习惯的最传统的方法（内存开销大了点）：

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)
        return NULL;
        vector<int>left_inorder_new,left_preorder_new,right_inorder_new,right_preorder_new;
        TreeNode*head=new TreeNode(preorder[0]);
        int root=0;
        for(int i=0;i<inorder.size();i++)
        {
            if(inorder[i]==preorder[0])
            {
                root=i;
                break;
            }
        }
        for(int i=0;i<root;i++)
        {
            left_inorder_new.push_back(inorder[i]);
        }
        for(int i=root+1;i<inorder.size();i++)
        {
            right_inorder_new.push_back(inorder[i]);
        }
        for(int i=0;i<root;i++)
        {
            left_preorder_new.push_back(preorder[i+1]);
        }
        for(int i=root+1;i<inorder.size();i++)
        {
            right_preorder_new.push_back(preorder[i]);
        }

        head->left=buildTree(left_preorder_new,left_inorder_new);
        head->right=buildTree(right_preorder_new,right_inorder_new);
        return head;


    }
};

自己改进的方法：

#include<iostream>
#include<vector>
using namespace std;
struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}

};
class Solution {
public:
	TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
		if (preorder.size() == 0)
			return NULL;
		return buildTreeCore(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
	}

	TreeNode* buildTreeCore(vector<int>& preorder, int pre_start, int pre_end, vector<int>& inorder, int in_start, int in_end) {
		if (pre_end < pre_start || in_end < in_start)
			return NULL;

		TreeNode*root = new TreeNode(preorder[pre_start]);


		//在中序序列中找根结点
		int root_index;
		for (int i = in_start; i <= in_end; i++)
		{
			if (inorder[i] == preorder[pre_start]) {
				root_index = i;
				break;
			}
		}

		int left_length = (root_index - 1) - in_start + 1;
		int right_length = in_end - (root_index + 1) + 1;

		root->left = buildTreeCore(preorder, pre_start + 1, pre_start + left_length, inorder, in_start, root_index - 1);
		root->right = buildTreeCore(preorder, pre_start + left_length + 1, pre_end, inorder, root_index + 1, in_end);
		return root;
	}
};

在这里插入图片描述

class Solution {
public:
	TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
		return buildTreeCore(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
	}

	TreeNode *buildTreeCore(vector<int> &inorder, int in_start, int in_end, vector<int> &postorder, int post_start, int post_end) {
		if (in_end < in_start || post_end < post_start)
			return NULL;
		TreeNode *root = new TreeNode(postorder[post_end]);
		int root_index;
		//在中序序列中找根结点
		for (int i = in_start; i <= in_end; i++)
		{
			if (inorder[i] == postorder[post_end])
			{
				root_index = i;
				break;
			}
		}

		int left_length = root_index - in_start;
		root->left = buildTreeCore(inorder, in_start, root_index - 1, postorder, post_start, post_start + left_length - 1);
		root->right = buildTreeCore(inorder, root_index + 1, in_end, postorder, post_start + left_length, post_end - 1);
		return root;
	}
};