C++ 二叉树(递归+循环)* 栈队*

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

结果

运行时间：7ms

占用内存：500k

知识点

• 二叉树
  • 创建
  • 遍历
  • 删除 语法参考
  • 增加 语法参考
• 栈 队
  • 创建
  • 遍历
  • 增加
  • 删除

//1）
/*
二叉树 听说底层是用数组实现的，自己可以去看看！
*/
struct tree{
	int data;
	tree *left;
	tree *right;
}
//2）
/*
二叉树 遍历:
前序（如下）、中序（a,b换位）、后续（a移动到最后）；
层序遍历
*/
void LookTree(tree * root){
	if(root == NULL){
		return;
	}
	cout<<root->data<< " ";//a
	LookTree(root->left);//b
	LookTree(root->right);//c
}
//层序遍历
void LevlOrder()//层序遍历
    {
        _LevlOrder(_root);
    }
void _LevlOrder(Node* root)//层序遍历依靠队列实现 循环实现
    {
        queue<Node*> q;
        if (NULL != root)
            q.push(root);
        while (!q.empty())
        {
            Node* front = q.front();
            cout << front->_data << " ";
            if (NULL != front->_left)
                q.push(front->_left);
            if (NULL != front->_right)
                q.push(front->_right);
            q.pop();
        }
        cout << endl;
    }

//3)
/*
二叉树的增加
*/
template<typename T>
void BST<T>::insert(BSTNode<T>* node)
{
    BSTNode<T>* curr, *temp = NULL;
    curr = root;
    while (NULL!= curr) //遍历二叉树，找到应该插入的父节点
    {
        temp = curr;
        if (node->data>curr->data)
        {
            curr = curr->rChild;
        }
        else {
            curr = curr->lChild;
        }
    }
    node->parent = temp;//temp 代码当前最后遍历的node，设置node->parent为该节点
    if (temp==NULL)
    {
        root = node;
        count++;
    }
    else {
        if (node->data<temp->data)
        {
            temp->lChild = node;
            count++;
        }
        else {
            temp->rChild = node;
            count++;
        }
    }
}

栈 队

在这里插入代码片

代码

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };CSDN博客创作如何实现 code折叠
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        //判断二叉树是否为空
        int inTreeLength = vin.size();
        if(inTreeLength == 0)
        {
            return NULL;
        }
        //创建节点，前序的第一个节点作为存储的头结点（根节点）
        TreeNode* tree = new TreeNode(pre[0]);//前序遍历每一次的第一个点都作为子树的根节点。
        //定义递归中要使用到的左子树（左节点，右节点）、右子树（左节点、右节点）
        vector<int> preLeft,preRight,vinLeft,vinRight;
       //递归输入的二叉树前序和中序，从树根向树枝寻找下一层根节点
        //首先找到二叉树根节点
        int equal= 0;//找到每个子树的根节点位置
        for(int i = 0; i < inTreeLength; i++)
        {
            if(pre[0] == vin[i])//前序的第一点为根节点，用来划分下一层的左右子树
            {
                equal = i;
                break;
            }
        }
        //左侧二叉树，左右节点
        for(int i = 0 ;i <equal; i++)
        {
            vinLeft.push_back(vin[i]);//添加到左子树下成为子叶（或子树根）
            preLeft.push_back(pre[i+1]);//前序第一个点为根节点，i+1为下一层的左子树根节点
        }
        //右侧二叉树
        for(int i = equal+1; i<inTreeLength;i++)
        {
            vinRight.push_back(vin[i]);
            preRight.push_back(pre[i]);
        }
            tree->left = reConstructBinaryTree( preLeft, vinLeft);
            tree->right = reConstructBinaryTree( preRight, vinRight);
        return tree;
    }
};

总结

会有内容的