精华内容
下载资源
问答
  • /* Name: 已知中序与后序,或者中序与先序构造二叉树 Copyright: 始发于goal00001111的专栏;允许自由转载,但必须注明作者出处 Author: goal00001111 Date: 08-12-08 11:42 Description: 描述 Description ...
    /*
    
      Name: 已知中序与后序,或者中序与先序,构造二叉树
      Copyright: 始发于goal00001111的专栏;允许自由转载,但必须注明作者和出处
      Author: goal00001111
      Date: 08-12-08 11:42
      Description:
    描述 Description      
    给出一棵二叉树的中序与后序排列。求出它的先序排列。
    给出一棵二叉树的中序与先序排列。求出它的后序排列。
    */

    #include<iostream>
    #include<string>

    using namespace std;

    typedef struct BTNode{
          char data;
          struct BTNode *lc, *rc;//左,右孩子指针
    } *BTree;

    void PostBtree(BTree & t, string mid, string post, int lm, int rm, int lp, int rp);
    void PreBtree(BTree & t, string mid, string pre, int lm, int rm, int lp, int rp);
    void Preorder(BTree p);  //先序遍历
    void Postorder(BTree p); //后序遍历

    int main(int argc, char* argv[])
    {
        string pre, mid, post;
        BTree root1, root2;
        
        cout << "输入中序序列" << endl;
        cin >> mid;
        cout << "输入后序序列" << endl;
        cin >> post;
        PostBtree(root1, mid, post, 0, mid.size()-1, 0, post.size()-1);
        Preorder(root1);
        cout << endl;
        
        cout << "输入前序序列" << endl;
        cin >> pre;
        PreBtree(root2, mid, pre, 0, mid.size()-1, 0, pre.size()-1);
        Postorder(root2);
        
        system("pause");
        return 0;
    }

    /*
    函数名称:PostBtree
    函数功能:给出一棵二叉树的中序与后序序列,构造这棵二叉树。
    输入参数: BTree & t:二叉树的结点t
              string mid:存储了二叉树的中序序列的字符串
              string post:存储了二叉树的后序序列的字符串
              int lm, int rm:二叉树的中序序列在数组mid中的左右边界
              int lp, int rp:二叉树的后序序列在数组post中的左右边界
    */
    void PostBtree(BTree & t, string mid, string post, int lm, int rm, int lp, int rp)
    {
        t = new BTNode; //构造二叉树根结点
        t->data = post[rp];
        t->lc = t->rc = NULL;
        
        int pos = lm;
        while (mid[pos] != post[rp])
            pos++;
        int lenL = pos - lm;
        if (pos > lm)//有左孩子,递归构造左子树
            PostBtree(t->lc, mid, post, lm, pos-1, lp, lp+lenL-1);
        if (pos < rm)//有右孩子,递归构造右子树
            PostBtree(t->rc, mid, post, pos+1, rm, lp+lenL, rp-1);
    }
    /*
    函数名称:PreBtree
    函数功能:给出一棵二叉树的中序与先序序列,构造这棵二叉树。
    输入参数: BTree & t:二叉树的结点t
              string mid:存储了二叉树的中序序列的字符串
              string pre:存储了二叉树的先序序列的字符串
              int lm, int rm:二叉树的中序序列在数组mid中的左右边界
              int lp, int rp:二叉树的先序序列在数组post中的左右边界
    */
    void PreBtree(BTree & t, string mid, string pre, int lm, int rm, int lp, int rp)
    {
        t = new BTNode; //构造二叉树根结点
        t->data = pre[lp];
        t->lc = t->rc = NULL;
        
        int pos = lm;
        while (mid[pos] != pre[lp])
            pos++;
        int lenL = pos - lm;
        if (pos > lm)//有左孩子,递归构造左子树
            PreBtree(t->lc, mid, pre, lm, pos-1, lp+1, lp+lenL);
        if (pos < rm)//有右孩子,递归构造右子树
            PreBtree(t->rc, mid, pre, pos+1, rm, lp+lenL+1, rp);
    }

    //先序遍历
    void Preorder(BTree p)
    {
        if(p != NULL)
        {
            cout << p->data; //输出该结点
            Preorder(p->lc); //遍历左子树
            Preorder(p->rc); //遍历右子树
        }
    }

    //后序遍历
    void Postorder(BTree p)
    {
        if(p != NULL)
        {
            Postorder(p->lc); //遍历左子树
            Postorder(p->rc); //遍历右子树
            cout << p->data; //输出该结点
        }
    }


    展开全文
  • 示例代码: #include using namespace std; struct BTNode {  int key;  BTNode *lchild;...BTNode * constructtree1(int *spre,int *epre,int *sinorder,int *einorder) //已知先序中序求后序 {

    示例代码:

    #include<iostream>
    using namespace std;
    struct BTNode
    {
     int key;
     BTNode *lchild;
     BTNode *rchild;
    };
    BTNode * constructtree1(int *spre,int *epre,int *sinorder,int *einorder) //已知先序、中序求后序
    {
      int rootValue=spre[0];
      BTNode *r=new BTNode();
      r->key=rootValue;
      r->lchild=r->rchild=NULL;

      int *rootInorder=sinorder;
      while(rootInorder<=einorder && *rootInorder!=rootValue)
       ++rootInorder;
      int length=rootInorder-sinorder;
      int * leftpreorderEnd=spre+length;
      if(length>0)
      {
       r->lchild=constructtree1(spre+1,leftpreorderEnd,sinorder,rootInorder-1);
      }
      if(length<epre-spre)
      {
       r->rchild=constructtree1(leftpreorderEnd+1,epre,rootInorder+1,einorder);
      }
      return r;
    }
    BTNode *constructtree2(int *sinorder,int *einorder,int *epostorder,int *spostorder) //已知后序、中序求先序
    {
       int rootValue=epostorder[0];
       BTNode * root=new BTNode();
       root->key=rootValue;
       root->lchild=root->rchild=NULL;
       int * rootInorder=sinorder;
       while(rootInorder<=einorder && *rootInorder!=rootValue)
        ++rootInorder;
       int length=rootInorder-sinorder;
       if(length>0)
       {
        root->lchild=constructtree2(sinorder,rootInorder-1,spostorder+length-1,spostorder);
       }
       if(length<epostorder-spostorder)
       {
        root->rchild=constructtree2(rootInorder+1,einorder,epostorder-1,spostorder+length);
       }
     return root;
    }
    void preorder(BTNode *r)
    {
     if(r==NULL)
      return;
     cout<<r->key<<endl;
     preorder(r->lchild);
     preorder(r->rchild);
    }
    int main()
    {
        int a[10]={1,2,4,7,3,5,6,8};
     int b[10]={4,7,2,1,5,3,8,6};
     int c[10]={7,4,2,5,8,6,3,1};
     BTNode *s;
     //s=constructtree1(a,a+7,b,b+7);
     s=constructtree2(b,b+7,c+7,c);
     preorder(s);
     return 0;
    }

    展开全文
  • 已知中序、后序构造二叉树 递归算法 def buildTree(inorder, postorder): if inorder and postorder: postRootVal = postorder.pop() inRootIdx = inorder.index(postRootVal) ...

    已知中序、后序构造二叉树

    递归算法

        def buildTree(inorder, postorder):
            if inorder and postorder:
                
                postRootVal = postorder.pop()
                inRootIdx = inorder.index(postRootVal)
                
                root = TreeNode(postRootVal)
                
                """ 解释:
                当从 postorder 中 pop 时,首先会命中 right child ,
                所以,在构造树时,需要先设置 right ,再设置 left 。
                """
                root.right = self.buildTree(inorder[inRootIdx+1:], postorder)
                root.left = self.buildTree(inorder[:inRootIdx], postorder)
                
                return root
    

    参考文献

    1. 106. Construct Binary Tree from Inorder and Postorder - LeetCode
    2. 这是印象笔记中的笔记,如果是在CSDN手机APP上查看此博客,请在印象笔记手机APP中搜索该参考文献:https://app.yinxiang.com/shard/s44/nl/9329661/e2a2758d-7c33-4fbd-99e0-74ff56457b82。
    展开全文
  • printf("输入二叉树中序先序序列,求后序序列\n"); gets(mid); gets(pre); midprecreat(Troot,mid,pre,0,n-1,0,n-1); print(Troot); printf("程序2 请输入节点个数\n"); scanf("%d",&n); getchar(); printf...
    
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct Bitree{
    	char data;
    	struct Bitree *lchild;
    	struct Bitree *rchild;
    }Bitree,*Bi;
    void PreOrder(Bitree *p);
    void MidOrder(Bitree *p);
    void PostOrder(Bitree *p);
    void print(Bitree *Troot);
     
    void midprecreat(Bi &Node,char mid[],char pre[],int lm,int rm,int lp,int rp)
    {//中序加先序创建 
    	Node=(Bi)malloc(sizeof(Bitree));
    	Node->data=pre[lp];
    	Node->lchild=NULL;
    	Node->rchild=NULL;
    	
    	int pos=lm;
    	
    	while(mid[pos]!=pre[lp])
    		pos++;
    	int childlen=pos-lm;//用来控制子树在字符串中的范围 
    	if(pos>lm)//有左子树,递归创建 
    		midprecreat(Node->lchild,mid,pre,lm,pos-1,lp+1,lp+childlen);
    	if(pos<rm)//有右子树,递创建
    		midprecreat(Node->rchild,mid,pre,pos+1,rm,lp+childlen+1,rp);
    }
     
    void midpostcreat(Bi &Node,char mid[],char post[],int lm,int rm,int lp,int rp)
    {//中序+后序创建 
    	Node=(Bi)malloc(sizeof(Bitree));
    	Node->data=post[rp];
    	Node->lchild=NULL;
    	Node->rchild=NULL;
    	
    	int pos=lm;
    	
    	while(mid[pos]!=post[rp])
    		pos++;
    	int childlen=pos-lm;//用来控制子树在字符串中的范围 
    	if(pos>lm)//有左子树,递归创建 
    		midpostcreat(Node->lchild,mid,post,lm,pos-1,lp,lp+childlen-1);
    	if(pos<rm)//有右子树,递创建
    		midpostcreat(Node->rchild,mid,post,pos+1,rm,lp+childlen,rp-1);
    }
    int main()
    {
    	char	pre[100];            //存储先序序列  
        char    mid[100];            //存储中序序列  
        char    post[100];           //存储后序序列  
    	int n;
    	Bitree *Troot;
    	printf("程序1请输入节点个数\n");
    	scanf("%d",&n);	getchar();
    	printf("输入二叉树的中序与先序序列,求后序序列\n");
    	gets(mid);
        gets(pre);
        midprecreat(Troot,mid,pre,0,n-1,0,n-1);
        print(Troot);
        
        printf("程序2 请输入节点个数\n");
    	scanf("%d",&n);	getchar();
    	printf("输入二叉树的中序与后序序列,求先序序列\n");
    	gets(mid);
        gets(post);
        midpostcreat(Troot,mid,post,0,n-1,0,n-1);
        print(Troot);
    	return 0;
    }
     
    void print(Bitree *Troot)
    {
    	printf("先序遍历结果:\n");
        PreOrder(Troot);
        printf("\n");
      
        printf("中序遍历结果:\n");
        MidOrder(Troot);  
        printf("\n");
      
        printf("后序遍历结果:\n");
        PostOrder(Troot);  
        printf("\n");  
    }
     
    //先序遍历  
    void PreOrder(Bitree *p)  
    {  
           if(p != NULL)  
           {  
                  printf("%c ",p->data);         //输出该结点  
                  PreOrder(p->lchild);  //遍历左子树   
                  PreOrder(p->rchild); //遍历右子树  
           }  
    }  
      
    //中序遍历  
    void MidOrder(Bitree *p)  
    {  
           if(p != NULL)  
           {  
                  MidOrder(p->lchild);   //遍历左子树   
                  printf("%c ",p->data);     //输出该结点  
                  MidOrder(p->rchild);  //遍历右子树  
           }  
    }  
     
    //后序遍历  
    void PostOrder(Bitree *p)  
    {  
           if(p != NULL)  
           {  
                  PostOrder(p->lchild);  //遍历左子树   
                  PostOrder(p->rchild); //遍历右子树  
                  printf("%c ",p->data);     //输出该结点  
           }  
    } 
    
    展开全文
  • package demoFive; /* *@author:张文波 ...//已知二叉树前序和中序序列,求二叉树 public class BuildTree { public static String xian="ABC"; public static String zhong="BAC"; public sta...
  • 构造二叉树并返回其根节点 法一:递归分治 对于任意一颗树而言,前序遍历的形式总是 [ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ] 即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是...
  • printf("输入二叉树中序先序序列,求后序序列\n"); gets(mid); gets(pre); midprecreat(Troot,mid,pre,0,n-1,0,n-1); print(Troot); printf("程序2 请输入节点个数\n"); scanf("%d",&n); getchar(); ...
  • 已知先序中序求后序public class BinaryTree1 { private Node root; public void postOrder(){ postOrder(root); } //二叉树构造完毕之后进行后续遍历 private void postOrder(Node localroot) { if(localr
  • 已知前序(先序)与中序输出后序: 前序:1, 2, 3, 4, 5, 6(根左右) 中序:3, 2, 4, 1, 6, 5(左根右) 分析:因为前序(根左右)最先出现的总是根结点,所以令root为前序中当前的根结点下标(并且同时把一棵树...
  • 已知二叉树先序序列为ABDGCEF,中序序列为DGBAECF,则构造二叉树的过程如下图。 详细过程如下: step1:先序序列为ABDGCEF,中序序列为DGBAECF          &...
  • 根据一棵树的前序遍历与中序遍历构造二叉树。 注意:你可以假设树中没有重复的元素。 例如,给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树: 二叉树深度遍历 先序...
  • 通过递归遍历的方法扫描先序中序构造二叉树; 通过递归遍历的方法扫描后序中序构造二叉树; 方法理解起来很简单,在纸上自己画画就知道如何去做了,该算法难点在于遍历中需要精确的数学计算,还需要清晰的判断...
  • 一棵二叉树先序遍历序列为EFHIGJK,中序遍历序列为HFIEJKG,则该二叉树根结点的右孩子为 A. H B. E C. F D. G
  • /*根据二叉树的前序序列和中序序列建立该二叉树。这个过程是 *一个递归过程,其基本思想是:先跟据前序序列的第一个元素建立 *根节点,然后在中序序列中找到该元素,确定根节点的左、右子树的中序序列; *再再...
  • 根据后序和中序先序: 按照常规思路递归实现,先递归生成左子树,再递归生成右子树 class node: #定义节点结构 def __init__(self, value = None, left = None, right=None): self.value = value self.left ...
  • 如题,已知先序中序/后序中序建立一棵二叉树。 我们手工建树的时候,比如一个例子:先序序列:ADECFG,中序序列:DBEAFCG。首先我们都会从先序序列中找到第一个元素A,该元素也就是这个树的根。然后再在中序序列中...
  • // preorder 这个数组的长度一定 inorder 是相同的. // 为了辅助遍历, 能够搞清楚当前 preorder 中访问到哪个元素了, // 还是通过 index 来记录一下 private int index = 0; public TreeNode buildTree(int[] ...
  • 官方题解...①与“已知后序中序,求先序”一样的左右递归方法(分而治之) ②*****迭代法,原理??? ...
  • LeetCode0105-从前序与中序遍历序列构造二叉树 题目: 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如,给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,...
  • Leetcode 105. 从前序与中序遍历序列构造二叉树
  • //9:08-9:47 我做的是先序和中序的,题目要求是后序中序 方法就是:首先需要在草图上明确先序后序区间,然后见代码吧一些语法 #include <stdio.h> #include using namespace std; int pre[30]={0},in[30]={0}...
  • 输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回...
  • 已知先序和中序即可唯一确定二叉树,由此构造
  • 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如,给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树: 3 / \ 9 20 / \ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,142
精华内容 856
关键字:

已知中序和先序构造二叉树