[PTA----树的遍历]

-Gaojs

已于 2022-07-02 18:29:45 修改

阅读量667

点赞数 1

分类专栏：数据结构 c++ 文章标签： c++ 数据结构算法

于 2022-06-29 20:44:35 首次发布

本文链接：https://blog.csdn.net/m0_65485466/article/details/125527600

版权

c++ 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

数据结构

8 篇文章 0 订阅

订阅专栏

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：
输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：
在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

输出样例：

4 1 6 3 5 7 2

分析

如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来在切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。
红字代表当前节点
由此可以知道此二叉搜索树为
在这里插入图片描述
那么代码应该怎么写呢？

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

第一步：如果数组大小为零的话，说明是空节点了。

第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）

第五步：切割后序数组，切成后序左数组和后序右数组

第六步：递归处理左区间和右区间

TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {

    // 第一步
    if (postorder.size() == 0) return NULL;

    // 第二步：后序遍历数组最后一个元素，就是当前的中间节点
    int rootValue = postorder[postorder.size() - 1];
    TreeNode* root = new TreeNode(rootValue);

    // 叶子节点
    if (postorder.size() == 1) return root;

    // 第三步：找切割点
    int delimiterIndex;
    for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
        if (inorder[delimiterIndex] == rootValue) break;
    }

    // 第四步：切割中序数组，得到 中序左数组和中序右数组
    // 第五步：切割后序数组，得到 后序左数组和后序右数组

    // 第六步
    root->left = traversal(中序左数组, 后序左数组);
    root->right = traversal(中序右数组, 后序右数组);

    return root;
}

在切割的过程中会产生四个区间，坚持循环不变量非常重要。首先要切割中序数组，为什么先切割中序数组呢？
切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必须要先切割中序数组。
中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，以下代码均坚持左闭右开原则。

int delimiterIndex;
for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
    if (inorder[delimiterIndex] == rootValue) break;
}

// 左闭右开区间：[0, delimiterIndex)
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
// [delimiterIndex + 1, end)
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

接下来就要切割后序数组了。

首先后序数组的最后一个元素指定不能要了，这是切割点也是当前二叉树中间节点的元素，已经用了。
后序数组的切割点怎么找？
后序数组没有明确的切割元素来进行左右切割，不像中序数组有明确的切割点，切割点左右分开就可以了。
此时有一个很重要的点，就是中序数组大小一定是和后序数组的大小相同的（这是必然）。
中序数组我们都切成了左中序数组和右中序数组了，那么后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。

// postorder 舍弃末尾元素，因为这个元素就是中间节点，已经用过了
postorder.resize(postorder.size() - 1);

// 左闭右开，注意这里使用了左中序数组大小作为切割点：[0, leftInorder.size)
vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
// [leftInorder.size(), end)
vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

综上：

class Solution {
private:
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;

        // 后序遍历数组最后一个元素，就是当前的中间节点
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 叶子节点
        if (postorder.size() == 1) return root;

        // 找到中序遍历的切割点
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 切割中序数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

如上的代码性能并不好，因为每层递归定义了新的vector（就是数组），既耗时又耗空间，我们可以对代码进行优化，不用重复定义vector，每次用下标索引来分割，思路完全一样。

class Solution {
private:
    // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
    TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
        if (postorderBegin == postorderEnd) return NULL;

        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorderEnd - postorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割后序数组
        // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
        int leftPostorderBegin =  postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
        // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
        int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
        int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        // 左闭右开的原则
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};

知道了二叉树的结构，接下来就是对二叉树进行层序遍历了。层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

void levelorder(TreeNode *root) {
	if (root == NULL) return;
	queue<TreeNode*> Q;
	Q.push(root);
	while (!Q.empty()) {
		TreeNode *current = Q.front();
		cout<<current->data<<" ";
		if (current->left != NULL) Q.push(current->left);
		if (current->right != NULL) Q.push(current->right);
		Q.pop();
	}
}//利用队列先进先出的性质存储节点

c++整体代码如下：

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int val) : val(val),left(nullptr),right(nullptr){}
};
class Solution {
private:
		TreeNode *traversal(vector<int> &inorder, int inorderBegin, int inorderEnd,
		vector<int> &postorder, int postorderBegin, int postorderEnd) {
			if (postorderBegin == postorderEnd) return NULL;
			int rootValue = postorder[postorderEnd-1];
			TreeNode *root = new TreeNode(rootValue);
			if (postorderEnd-postorderBegin == 1) return root;
			int delimiterIndex;
			for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
				if (inorder[delimiterIndex] == rootValue) break;
			}
			int leftInoderBegin = inorderBegin;
			int leftInorderEnd = delimiterIndex;
			int rightInorderBegin = delimiterIndex + 1;
			int rightInorderEnd = inorderEnd;
			int leftPostorderBegin = postorderBegin;
			int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin;
			int rightPostorderBegin = leftPostorderEnd;
			int rightPostorderEnd = postorderEnd - 1;
			root->left = traversal(inorder,leftInoderBegin,leftInorderEnd,postorder,
			leftPostorderBegin,leftPostorderEnd);
			root->right = traversal(inorder,rightInorderBegin,rightInorderEnd,postorder,
			rightPostorderBegin,rightPostorderEnd);
			return root;
		}
	public:
		TreeNode *buildTree (vector<int>& inorder, vector<int>& postorder) {
			if (inorder.size() == 0 || postorder.size() == 0) return NULL;
			return traversal(inorder,0,inorder.size(),postorder,0,postorder.size());
		}
	vector<int> levelorder(TreeNode *root) {
		vector<int> result;
		if (root == NULL) result;
		queue<TreeNode*> Q;
		Q.push(root);
		while (!Q.empty()) {
			TreeNode *current = Q.front();
			result.push_back(current->val);
			if (current->left != NULL) Q.push(current->left);
			if (current->right != NULL) Q.push(current->right);
			Q.pop();
		}
		return result;
	}//利用队列先进先出的性质存储节点
 };
 int main() {
 	TreeNode *root = NULL;
 	Solution Q;
 	int n;
 	cin>>n;
 	vector<int> inorder(n);
 	vector<int> postorder(n);
 	vector<int> result;
	 for (int i = 0; i < n; i++) {
	 	cin>>postorder[i];
	 }
	for (int i = 0; i < n; i++) {
		 	cin>>inorder[i];
	 }
	 root = Q.buildTree(inorder,postorder);
     result = Q.levelorder(root);
	 for (int i = 0; i < result.size(); i++) {
	 	cout<<result[i];
	 	if(i != result.size()-1) cout<<" ";
	 }
 }