精华内容
下载资源
问答
  • main函数 int main() { Bitree* T=NULL; printf("输入二叉树的先序遍历结点,建立二叉树。(子树为空时输入@)\n"); T=CreateBtree_DLR(T); printf("\n先序遍历的结果:\n");...先序遍历建立二叉树 Bitr

    main函数

    int main()
    { Bitree* T=NULL;
      printf("输入二叉树的先序遍历结点,建立二叉树。(子树为空时输入@)\n");
      T=CreateBtree_DLR(T);
    
      printf("\n先序遍历的结果:\n");
      PreOrder(T);
      printf("\n中序遍历的结果:\n");
      InOrder(T);
      printf("\n后序遍历的结果:\n");
      PostOrder(T);
    return 0;
    }
    

    先序遍历建立二叉树

    Bitree* CreateBtree_DLR(Bitree* root)
    { char ch;
      scanf("%c",&ch);
      if(ch=='@')
      root=NULL;
      else
      {
      root=(Bitree*)malloc(sizeof(Bitree));
      root->data=ch;
      root->lchild=CreateBtree_DLR(root->lchild); //构造左子树
          root->rchild=CreateBtree_DLR(root->rchild); //构造右子树
      }
      return(root);
    }
    

    通过循环调用建立二叉树

    void PreOrder(Bitree* T)    //先序遍历二叉树
    {
       if ( T!=NULL ) 
        {  printf("%c ",T->data);
           PreOrder(T->lchild);
           PreOrder(T->rchild);
        }
    }
    
    void InOrder(Bitree* T)    //中序遍历二叉树
    {
       if ( T!=NULL ) 
        {   InOrder(T->lchild);
    		printf("%c ",T->data);       
            InOrder(T->rchild);
        }
    }
    
    void PostOrder(Bitree* T)    //后序遍历二叉树
    {
       if ( T!=NULL ) 
        {   PostOrder(T->lchild); 
            PostOrder(T->rchild);
            printf("%c ",T->data);   
        }
    }
    

    全部代码

    #include <stdio.h>
    #include <stdlib.h>
    typedef char Elemetype;
    
    typedef struct BiTNode    //定义二叉链表的结构体
    {  Elemetype data;
       struct BiTNode *lchild,*rchild;
     }Bitree;
    Bitree* CreateBtree_DLR(Bitree* root); //以先序遍历建立二叉树
    void PreOrder(Bitree* T);    //先序遍历二叉树
    void InOrder(Bitree* T);    //中序遍历二叉树
    void PostOrder(Bitree* T); //后序遍历二叉树
    
    int main()
    { Bitree* T=NULL;
      printf("输入二叉树的先序遍历结点,建立二叉树。(子树为空时输入@)\n");
      T=CreateBtree_DLR(T);
    
      printf("\n先序遍历的结果:\n");
      PreOrder(T);
      printf("\n中序遍历的结果:\n");
      InOrder(T);
      printf("\n后序遍历的结果:\n");
      PostOrder(T);
    return 0;
    }
    Bitree* CreateBtree_DLR(Bitree* root)
    { char ch;
      scanf("%c",&ch);
      if(ch=='@')
      root=NULL;
      else
      {
      root=(Bitree*)malloc(sizeof(Bitree));
      root->data=ch;
      root->lchild=CreateBtree_DLR(root->lchild); //构造左子树
          root->rchild=CreateBtree_DLR(root->rchild); //构造右子树
      }
      return(root);
    }
    void PreOrder(Bitree* T)    //先序遍历二叉树
    {
       if ( T!=NULL ) 
        {  printf("%c ",T->data);
           PreOrder(T->lchild);
           PreOrder(T->rchild);
        }
    }
    void InOrder(Bitree* T)    //中序遍历二叉树
    {
       if ( T!=NULL ) 
        {   InOrder(T->lchild);
    		printf("%c ",T->data);       
            InOrder(T->rchild);
        }
    }
    void PostOrder(Bitree* T)    //后序遍历二叉树
    {
       if ( T!=NULL ) 
        {   PostOrder(T->lchild); 
            PostOrder(T->rchild);
            printf("%c ",T->data);   
        }
    }
    

    运行结果
    在这里插入图片描述
    在这里插入图片描述
    看完点赞,谢谢!

    展开全文
  • 以扩展的先序遍历建立二叉树,根结点的地址通过函数值返回。例如输入AB#DF##G##C##,建立二叉树如下图,二叉树.png输出该二叉树的先序遍历序列ABDFGC。#include <stdio.h> #include <stdlib.h> typedef ...

    以扩展的先序遍历建立二叉树,根结点的地址通过函数值返回。

    例如

    输入AB#DF##G##C##,建立二叉树如下图,

    二叉树.png

    输出该二叉树的先序遍历序列ABDFGC。

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef char ElementType;
    typedef struct BiTNode {
        ElementType data;
        struct BiTNode* lchild;
        struct BiTNode* rchild;
    }BiTNode, * BiTree;
    
    BiTree CreatBinTree();
    void  preorder(BiTree T);
    
    int main()
    {
        BiTree T = CreatBinTree();
        preorder(T);
        return 0;
    }
    void  preorder(BiTree T)
    {
        if (T)
        {
            printf("%c", T->data);
            preorder(T->lchild);
            preorder(T->rchild);
        }
    }
    BiTree CreatBinTree()
    {
        char ch; BiTree T;
        scanf("%c", &ch);
        if (ch == '#')//如果当前字符为#时说明当前节点为空,return NULL
            return NULL;
        T =(BiTree*)malloc(sizeof(BiTree));
        T->data = ch;
        T->lchild =CreatBinTree();//调用函数建立左孩子
        T->rchild =CreatBinTree();//调用函数建立右孩子
        return T;
    }
    展开全文
  • 此部分是对于数据结构的边缘部分的理解 #include #include using namespace std; struct node { char data; node *leftchild;...void Create(node *&p)//扩展先序遍历建立二叉树 { char ch; cin>>

    此部分是对于数据结构的边缘部分的理解

    #include <iostream>
    #include<stack>
     using namespace std;
     struct node
     {
         char data;
         node *leftchild;
         node *rightchild;
    };
    void Create(node *&p)//扩展先序遍历建立二叉树
    {
        char ch;
        cin>>ch;
        if (ch=='#')
            p=NULL;
        else
        {
            p=new node;
            p->data=ch;
            Create(p->leftchild);
            Create(p->rightchild);
        }
    }
    void PreOrder(node *root)
    {
        stack<node*>s;
        node *p;
        s.push(NULL);
        p=root;
        while(!s.empty())
        {
            if (p==NULL)
            break;
           cout<<p->data<<" ";
           if (p->rightchild!=NULL)//如果右子树不为空,那么将右子树入栈
                s.push(p->rightchild);
           if (p->leftchild!=NULL)//如果左子树不为空,那么将当前节点迭代为它的左孩子
              p=p->leftchild;
           else//如果左子树为空,那么就从栈中取出一个节点
              {
               p=s.top();
               s.pop();
              }
        }
    }
    void PosrOrder(node *root)//中序遍历思路是先不断遍历左节点(只是遍历,并不访问,第一个访问应当是最左边的),如果该节点不为空则将其入栈,同时继续访问它的左节点,如果左节点为空了,就从栈中取出一个元素,输出它的值,同时将指针指向它的右节点
    //注意这里是理解的难点,为什么要置为右节点,因为实际上该点的左子树已经访问过了,退回父节点由将父节点访问过了,此时要访问它的右子树,而访问右子树的过程应重复上述过程,即又是先重复访问左节点
    {
        node *p=root;
        stack<node*>s;
       while(p||!s.empty())//正常应该是栈不为空,但考虑到第一次判断的情况(第一次肯定要将根节点入栈的),所以要让p不为空也放入,那后面会出现p为空但栈中没有元素的情况吗,显然不会,因为只要p不为空都只会往栈中加元素,根本不会取出元素
        {
           if (p)
           {
            s.push(p);
            p=p->leftchild;
           }
           else//当为空,就从栈中取出一个节点
           {
               p=s.top();
               s.pop();
               cout<<p->data<<" ";
               p=p->rightchild;
           }
        }
    
    }
    int main()
    {
        node *root;
        Create(root);
        cout<<"先序遍历结果为:";
        PreOrder(root);
        cout<<endl;
        cout<<"中序遍历结果为:";
        PosrOrder(root);
        cout<<endl;
        return 0;
    
    }
    

    毫无疑问我的先序遍历的代码复杂了,单独上个简洁的代码~~


    void PreOrderTraverse(BTNode *T, Status (*visit)(ElementType e))
    {
        BTNode *stack[MAX_SIZE], *p;
        int top = -1;
        if(T != NULL)    {
            stack[++top] = T;
            while(top > -1)
            {
                p = stack[top--];
                visit(p->data);
                if(p->rchild != NULL)
                {
                    stack[++top] = p->rchild;
                }
                if(p->lchild != NULL)
                {
                    stack[++top] = p->lchild;
                }
            }
        }
    }
    



    展开全文
  • 1、二叉树的数据结构:二叉链表 package BT; public class BinearyTree&lt;E&gt; {  E data;   BinearyTree&lt;E&gt; lchild;  BinearyTree&lt;E&gt; rchild;  public BinearyTree(E...

    1、二叉树的数据结构:二叉链表

    package BT;

    public class BinearyTree<E> {
            E data; 
            BinearyTree<E> lchild;
            BinearyTree<E> rchild;
            public BinearyTree(E data){
                this.data=data;
            }
    }

    2、先序建立二叉树:

    A B D * F * * * C E * * *:*代表为null

    private static BinearyTree<String> createBinaryTreeByPreorder(BinearyTree<String> bt) {
            // TODO Auto-generated method stub
            System.out.println("请输入当前节点的数据域:");
             data=scan.nextLine();
             if(data.equals("*")){
                 bt=null;
             }else{
                 bt=new BinearyTree<String>(data);
                 bt.lchild= createBinaryTreeByPreorder(bt.lchild);
                 bt.rchild= createBinaryTreeByPreorder(bt.rchild);
             }
             return bt;
        }

    3、先序遍历二叉树

    private static void preOrder(BinearyTree<String> root) {
            // TODO Auto-generated method stub
            if(root!=null) {
                System.out.println(root.data);
                preOrder( root.lchild);
                preOrder( root.rchild);
            }
        }
    4、测试代码:

    public class CreateBinaryTreeByPreorder {
        static Scanner scan;
        static String data;
        static {scan=new Scanner(System.in);}

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            BinearyTree<String> root = null;
            root=createBinaryTreeByPreorder(root);
            //System.out.println(root.lchild.data);
            preOrder(root);
        }

        private static void preOrder(BinearyTree<String> root) {
            // TODO Auto-generated method stub
            if(root!=null) {
                System.out.println(root.data);
                preOrder( root.lchild);
                preOrder( root.rchild);
            }
        }

        private static BinearyTree<String> createBinaryTreeByPreorder(BinearyTree<String> bt) {
            // TODO Auto-generated method stub
            System.out.println("请输入当前节点的数据域:");
             data=scan.nextLine();
             if(data.equals("0")){
                 bt=null;
             }else{
                 bt=new BinearyTree<String>(data);
                 bt.lchild= createBinaryTreeByPreorder(bt.lchild);
                 bt.rchild= createBinaryTreeByPreorder(bt.rchild);
             }
             return bt;
        } 
    }
    测试结果:

    请输入当前节点的数据域:
    A
    请输入当前节点的数据域:
    B
    请输入当前节点的数据域:
    D
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    F
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    E
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    *
    请输入当前节点的数据域:
    *
    A B D F C E 

    展开全文
  • 先序序列创建二叉树 tree creat(){ //前序序列创建二叉树 tree t; int ch; scanf("%d",&amp;ch); if(ch==0) { t=NULL;} else{ t=(tree)malloc(sizeof(node)); t-&gt;data=ch; t-&...
  • void build_pre(node*& one_node,queue<Elemtype>& q)//入口这里的指针意思是有意愿在某处建立结点 { if (q.empty() != true) { if (q.front() == '#') { one_node = NULL;//这个结点指向空,空不...
  • 二叉树遍历 #include <cstdio> #include <iostream> #include <string> #include <queue> using namespace std; void visit(char c){ cout<<c<<" "; return ; } struct ...
  • 输入:每行3个数字,第一个数字表示左子数节点个数,...0 0 1对应的二叉树就是,先序遍历为4-2-3-1,中序遍历为2-4-1-3。 我们先来按照要求建树,直接就是先序遍历,来看实现: #include<iostream> us...
  • title: 根据先序遍历和中序遍历建立二叉树 date: 2019-07-23 22:37:34 tags: 数据结构 问题 已知一棵二叉树的先序遍历以及中序遍历,重建二叉树。二叉树的每一个节点有三个属性,左子节点,右子节点,以及...
  • 假设现在有某二叉树先序遍历和中序遍历,我们应该如何建树? 基本思路: 分别求得根节点的左子树和右子树的先序遍历序列与中序遍历序列 分别以左子树和右子树为新树进行第一步操作 直至没有子树为止 那么我们...
  • 先序遍历和中序遍历建立二叉树,并且以后续遍历输出二叉树 假设先序遍历为:abcdefghi(根 左 右) 中序遍历为:bcaedghfi (左 根 右) 首先在先序遍历中可以确认a为根节点 在中续遍历中可以看到bc(初始位置为b...
  • 思路:通过先序遍历建立链式二叉树 思路是对的,但是在实现的过程中,出现了一些问题。 错误代码: //结构体 typedef struct BTNode { char data; struct BTNode *pLchild; struct BTNode *pRchild; }BTNODE, *...
  • printf("下面先序遍历建立二叉树:\n");   DLRcreat(T);               printf("下面输出先序遍历的二叉树结点:\n");   DLRorder(T);               printf("\n");   printf("下面输出先序...
  • 一、已知先序遍历顺序,构建二叉树。(链式存储) 二、已知层次遍历顺序,构建二叉树。(链式存储) 三、已知节点关系,建立二叉树(邻接表存储) 四、已知先序和中序遍历顺序,建立二叉树。 前提知识: ...
  • 题目: 根据先序遍历和中序遍历建立二叉树的二叉链表 并输出后序序列 思路: 根据先序序列确定根节点 在中序序列中找到根节点,将中序序列分成两段,前半段为根节点的左子树的中序序列,后半段为右子树的中序序列 ...
  • 中序遍历和先序遍历/后序遍历构建二叉树
  • 根据二叉树先序遍历和中序遍历构建二叉树

    万次阅读 多人点赞 2019-04-24 21:20:37
    对于本题,根据二叉树先序遍历和中序遍历构建二叉树,思路: 我们可以求得根节点左子树的先序和中序序列,以及右子树的先序和中序序列 此问题变成了根据左子树的先序和序列构建左子树的二叉树,根据右子树的先序和...
  • 输入二叉树的带空指针的先序遍历结果,生成二叉树,返回指向二叉树根节点的指针。
  • 先序遍历和中序遍历构建二叉树详解 /* 先序 + 中序 = 二叉树 */ #include<iostream> #include<stdio.h> using namespace std; typedef struct BTreeNode { int data; BTreeNode *Lchild, *Rchild; }...
  • 根据先序遍历和中序遍历创建二叉树 分析过程 char *VLR = “ABCDEFGH”; char *LVR = “CBEDFAGH”;先序遍历是 ABCDEF,中序遍历是CBEDFAGH 先序遍历先是根节点,则A是根节点,此时根据中序遍历可以知道左孩子...
  • // 利用先序遍历创建二叉树 // 参数:先序遍历字符串s,字符串初始下标i=0,字符串长度len。 // 返回:二叉树 { // 请在这里补充代码,完成本关任务 /********** Begin *********/ BiTreeNode* root; char item ...
  • 由中序和先序遍历序列建立二叉树 def createBiTree(preOrder,inOrder,preo,ino,n): if n>0: i = 0 c = preOrder[preo] # c为先序序列的根结点 while i<n: if inOrder[i+ino]==c: break i += 1 ...
  • 递归的方法利用先序遍历和中序遍历构建二叉树,同样也可以利用到中序遍历和后序遍历构建二叉树。 //利用先序遍历和中序遍历构建二叉树 TreeNode* buildTree(vector<int>& preorder, vector<int>...
  • 根据先序遍历建立一个二叉树

    万次阅读 2017-04-25 23:26:38
    编一个程序,读入用户输入的一串先序遍历字符串,根据此字符串建立一个二叉树(以指针方式存储)。...输出:可能有多组测试数据,对于每组数据,输出将输入字符串建立二叉树后中序遍历的序列,每个字符后面都有一个空
  • 先序递归遍历建立二叉树的方法为:按照先序递归遍历的思想将对二叉树结点的抽象访问具体化为根据接收的数据决定是否产生该结点从而实现创建该二叉树的二叉链表存储结构。约定二叉树结点数据为单个大写英文字符。当...
  • 中序遍历+后序/先序遍历构建二叉树@(算法学习)给定中序+先序,中序+后序可以唯一构建一棵二叉树。给定先序+后序,无法唯一确定,但是却是很好的考点,问总共有多少种可能。。。如2016.9月份PAT最后一题就是考察这个...
  • 题目要求: 二叉树是一个重要的数据类型,通过建立一个链式存储结构,能够实现前序遍历,中序遍历,后序遍历。...具体分别是先序遍历二叉树:利用二叉链表作为存储结构的先序遍历,先访问根结点,在依次访问左右
  • 首先我们要明白先中后序遍历的特点: 先序遍历中 第一个一定是根结点。 中序遍历中 根结点左子树的...根据先序遍历和中序遍历构建二叉树 解题细想: 设置变量inedx 方便从preorder数组中获取元素构建结点。 判断i...
  • 先序遍历构造二叉树

    2019-08-14 11:56:24
    返回与给定先序遍历preorder 相匹配的二叉搜索树(binary search tree)的根结点。 (回想一下,二叉搜索树是二叉树的一种,其每个节点都满足以下规则,对于node.left的任何后代,值总 < node.val,而 node.right...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,256
精华内容 5,702
关键字:

先序遍历建立二叉树