精华内容
下载资源
问答
  • [问题描述] 建立二叉树,并输出二叉树的先序,中序和后序遍历序列,以及二叉树的叶子数。 [基本要求] 要求根据读取的元素建立二叉树,能输出各种遍历。 [实现提示] 可通过输入带空格的前序序列建立二叉链表。
  • 1.广义表创建二叉树 比如:A(B(,G),C(D(F),E)) 2.二叉树输出广义表
  • Java实现二叉树的3种方式,顺序二叉树的实现,二叉树的三叉链表存储,二叉树的二叉链表实现
  • 递归的方式创建二叉树
  • 主要介绍了python使用递归的方式建立二叉树,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • c++创建二叉树

    2013-11-25 21:35:27
    c++创建二叉树,实现前、中、后序输出,以及计算输的叶节点、深度高度等
  • 创建二叉树

    2020-05-28 15:37:02
    创建二叉树 开发工具与关键技术: 作者: 撰写时间:2020年5月27日 一棵二叉树是结点的一个有限集合,该集合或者为空,或者是由一个根节点加上两颗分别称为左子树和右子树的、相互不相交的二叉树组成,每个结点...

    创建二叉树

    开发工具与关键技术:

    作者:                      

    撰写时间:2020年5月27

     一棵二叉树是结点的一个有限集合,该集合或者为空,或者是由一个根节点加上两颗分别称为左子树和右子树的、相互不相交的二叉树组成,每个结点最多只有两个孩子。

    二叉树的顺序存储结构,用一组连续的的存储单元存放二叉树中的元素,即按满二叉树的形式存放在一维数组中。

    由于在顺序储存结构中是以结点在数组中相对位置表示结点之间的关系,因此,一般二叉树也必须以完成二叉树的形式来储存,可能未造成坤存储空间的浪费。

    在二叉树的链式存储结构,最常用的是二叉链表和三叉链表,二叉链表的每个结点有一个数据与和两个指针域,一个指针指向左孩子,另一个指向右孩子。如下图所示:

    在创建二叉树之前首先要想到,二叉树的三种遍历方法或二叉树的者操作,是建立在这个内存已经有了这个二叉树的基础上来做的,但是事实上内存中没有这棵二叉树,是需要我们建立二叉树,那二叉树是如何创建的呢?.

    如果二叉树自已链表存储方式,首先第一个节点先根遍历,所以第一个节点肯定是根,然后到它的左子树B,B的左子树先根遍历是D,可是D的左右孩子为空,并且B的孩子为空,到A的右孩子C,C的左孩子是E,然后E的左右孩子是空,然后C的孩子是F,F的左右孩子都为空,这样整个二叉树的创建就完成了。

     

    下面我们来看一下创建二叉树的代码,它的序列是AB,用#代表空集,我们做的时候就需要输入字符,把字符判断一下,如果是为#,那么二叉树为空,首先要分配一个新的结点,另一个结点我们当成是跟,如果分配成功我们把ch赋值给data域,然后不断地递归创建它的左子树和右子树,其实这是一个递归的过程,我们再次输入一个数据域,这个数据域当作他的左子树,因为这是先根遍历先做左子树一直到空为止在做它的右子树。

     

     

     

    展开全文
  • 链表创建二叉树

    2013-06-02 20:52:06
    有关于数据结构中链表创建二叉树实现其功能
  • 建立二叉树

    2012-11-10 23:27:01
    //编一个程序,读入用户输入的一串先序遍历字符串,根据此字符串建立一个二叉树(以指针方式存储)。 //例如如下的先序遍历字符串: //ABC##DE#G##F### //其中“#”表示的是空格,空格字符代表空树。建立起此二叉树...
  • 创建一个二叉树 二叉树有限多个节点的集合,这个集合可能是: 空集 由一个根节点,和两棵互不相交的,分别称作左子树和右子树的二叉树组成 创建二叉树创建节点,再创建节点之间的关系 Python代码示例 # !/...
  • C++创建二叉树及操作

    2012-04-19 20:38:16
    C++创建二叉树及操作包括前序遍历后序遍历层序遍历 深度 叶子节点
  • (1)输入字符序列,建立二叉链表。 (2)先序、中序、后序遍历二叉树:递归算法。 (3)中序遍历二叉树:非递归算法(最好也能实现先序,后序非递归算法)。 (4)求二叉树的高度 。 (5)求二叉树的叶子个数。 ...
  • 建立二叉树的几种方法

    千次阅读 2019-11-13 20:02:47
    建立二叉树的几种方法 1.书上(前序创建二叉树) void _Create1(BinNode * &root,char ch[],int &k,char c) //先序方式建树 //这里的ch数组是要建立的二叉树的先序遍历的序列,char c 是节点为空的标志。...

    建立二叉树的几种方法

    1.书上(前序创建二叉树)
    //先序方式建树
    //这里的ch数组是要建立的二叉树的先序遍历的序列,char c //是节点为空的标志。

    
    ```cpp
    void _Create1(BinNode <T>  * &root,char ch[],int &k,char c) 
    			{
    			    if(ch[k]==c)
    			        return;
    			    else{
    			        root=new BinNode <T>();
    			        root->data=ch[k];
    			        ++k;
    			        _Create1(root->lchild,ch,k,c);
    			        ++k;
    			        _Create1(root->rchild,ch,k,c);
    			    	}
    			}
    
    void Create1(char ch[],int k,char c)
    {
        if(strlen(ch)==0)
            return ;
        _Create1(root,ch,k,c);
    }
    

    2.简化第一种方法

    //第二个参数只要传数组名即可。

    void Create2(BinNode<T> *  &p,char * &str)
    {
        if(str!=NULL && * str != '*')
        {
            (p) = new BinNode<T>();
            (p)->data =*str;
            Create2((p)->lchild,++str);
            Create2((p)->rchild,++str);
        }
    }
    

    3.利用前序和后序创建二叉树

    //n为树的节点个数;
    BinNode<T> * _Creat3(char ps[],char is[],int n) 
    {
        if(n<=0)
            return NULL;
        int i=0,m;
        while (i < n)
        {
            if(ps[0] == is[i])
            {
                m = i;
                break;
            }
            ++i;
        }
        if(i>=n)
            return NULL;
        BinNode <T> * p=new BinNode <T> ();
        p->data=ps[0];
        p->rchild=_Creat3(ps+m+1,is+m+1,n-m-1);
        return p;
    }
    //此时的m为临界点 is数组中下标<m的是ps[0]的左子树,大于m的为右子树。
        p->lchild=_Creat3(ps+1,is,m);//因为第一个结点已经建立好了,ps往后以一位;
    void Creat3(char ps[],char is[],int n)
    {
        root=_Creat3(ps, is, n);
    }
    
    展开全文
  • 二叉树建立

    2018-01-17 15:09:53
    此代码详细的分析了二叉树建立,三种遍历二叉树,前序递归,中序递归,后序递归
  • 建立二叉树的几种方法: 一、已知先序遍历顺序,构建二叉树。(链式存储) 二、已知层次遍历顺序,构建二叉树。(链式存储) 三、已知节点关系,建立二叉树(邻接表存储) 四、已知先序和中序遍历顺序,建立...

    其他二叉树知识!二叉树知识汇总


    目录

    前提知识:

    约定:

    二叉树节点的存储结构:

    创建一个节点:

    建立二叉树的几种方法:

    一、已知先序遍历顺序,构建二叉树。(链式存储)

    二、已知层次遍历顺序,构建二叉树。(链式存储)

    三、已知节点关系,建立二叉树(邻接表存储)

    四、已知先序和中序遍历顺序,建立二叉树。

     


    前提知识:

     

    约定:

    约定二叉树的内容为int类型,并且都>=1,0代表是空节点。我们一般画的二叉树为图一,但是计算机中存储时真实的样子是图二,即需要考虑空节点,不然的话,计算机不知道这个节点已经到头了。

              

    例子中树的先序遍历为:1 2 4 3 5 6

    若是考虑每个节点的两个空节点,则先序遍历为:1 2 4 0 0 0 3 5 0 0 6 0 0

    二叉树节点的存储结构:

    struct Node{
    	int data;
    	Node* leftchild;
    	Node* rightchild; 
    };

    一个存储数据的data,左右两个指针都是节点的指针类型。

    创建一个节点:

    void Create_Node(Node* &t,int x){  //在指针t处生成一个新的节点,内容为x
    	t=new Node;
    	t->data=x;
    	t->leftchild=NULL;
    	t->rightchild=NULL;
    }

    开辟一个新的Node类型空间,并将地址赋值给指针t。(原来t指向NULL,现在指向了我们生成的新节点,这就是创建节点的过程)

    另外新节点*t的左右孩子要指向NULL,这代表节点到此结束,不赋初值会导致一些错误。

    参数的问题:

    Node * &t 这个参数表示传入的是一个Node类型的指针变量,并且是引用传递,因为我们要修改实参的值,所以要用引用传递。

    不懂引用的看这里:https://blog.csdn.net/qq_21989927/article/details/107447970

     

    建立二叉树的几种方法:

     

    一、已知先序遍历顺序,构建二叉树。(链式存储)

    这里的先序遍历顺序,必须是包含空节点的,不然是无法确定二叉树的。

    样图中的数的先序遍历顺序:1 2 4 0 0 0 3 5 0 0 6 0 0

    void Create_Pre(Node* &t){
    	int x; 
    	cin>>x;
    	if (x==0) return;
    	else{
    		Create_Node(t,x);
    		Create_Pre(t->leftchild);
    		Create_Pre(t->rightchild);
    	} 
    }
    

    对于输入的x,若是0,说明是空节点,直接返回return。

    若不是空节点,则调用前提知识中的Create_Node函数,在此处创建一个新节点,接着再递归新节点的左右孩子。

    因为已知的是先序遍历顺序,所以我们是按先访问根,再访问左右孩子的顺序。

     

    二、已知层次遍历顺序,构建二叉树。(链式存储)

    这里又分两种方法:一种是边读入数据边建立二叉树,需要用到队列;另一种是已知的层次遍历顺序在数组中存放好了。

    1.使用队列

    这种方法样例对应的读入是:1 2 3 4 0 5 6 0 0 0 0 0 0  (0是空节点)

    void Create_Level(Node* &t){
    	queue<Node*> q;
    	int x;
    	cin>>x;
    	if (x!=0) {
    		Create_Node(t,x);
    		q.push(t);
    	}
    	while (!q.empty()){
    		Node* s=q.front();
    		cin>>x;
    		if (x!=0){
    			Create_Node(s->leftchild,x);
    			q.push(s->leftchild);
    		}
    		cin>>x;
    		if (x!=0){
    			Create_Node(s->rightchild,x);
    			q.push(s->rightchild);
    		}
    		q.pop();
    	}
    }

    使用队列的方法,首先要入读一个x,判断这棵树是否存在,若是0,说明空树,不为0,创建节点后入队。

    当队列不为空时,队列中每一个元素都需要再读取两个数字(就算是叶子节点也起码也得读两个0)。

    这种方法建立二叉树,执行过程中会发现,每次读取的两个数,对应的都是队首元素的左右孩子,这和给定的层次遍历顺序对应。

    2.使用数组

    给定的层次遍历已经存放在数组中,我们只需要判断一个节点的左右孩子是否存在即可,左孩子为i*2,右孩子为i*2+1。

    注意要从a[1]开始存储,a[0]不用。

    int a[100]={0,1,2,3,4,0,5,6};
    void Create_Tree(Node* &t,int i){
    	if (a[i]==0) return;
    	Create_Node(t,a[i]);
    	if (a[i*2]!=0) Create_Tree(t->leftchild,i*2);
    	if (a[i*2+1]!=0) Create_Tree(t->rightchild,i*2+1);
    }
    

    3.两种方法的区别:

    建造过程的不同:

    利用队列,树是一层一层被构造出来的,对数据的访问也是严格按照层次遍历的顺序执行的;

    利用数组,树的构造过程实际上是先根,再左孩子,再右孩子的。通过跳跃访问数组内容,实现的是先序遍历建立二叉树。

    输入数据的不同:

    如果一棵树如图:

    对于队列的方法,   输入为 1 0 3 5 6 0 0 0 0

    对于数组的方法,数组中:1 0 3 0 0 5 6 0 0 0 0 

    因为对于队列来,如果一个节点为空节点,那么自然不会加入队列,也不会再去访问他。

    而对于数组来说,要严格执行左孩子是*2,右孩子是*2+1的规则,所以空间浪费会很多。

     

    三、已知节点关系,建立二叉树(邻接表存储)

    假设题目输入中,我们只知道 x , y 之间有一条边,但是并不知道 x , y 的父子关系的时候,可以使用邻接表的方法存储树。
    这时候把树看做一个图,建边要建双向边,然后在从根做dfs,确定每个节点的深度,顺便也可以求出每个节点的父亲节点,这样节点之间的父子关系就清楚了。

    例题:
    第一行输入N、root,表示这棵树有N个节点,根为root。
    接下来 N-1 行每行包含两个正整数 x, y,表示 x 结点和 y 结点之间有一条直接连接的边(数据保证可以构成树)。

    求每个节点的深度和每个节点的父亲节点。

    代码:

    #include<iostream>
    using namespace std;
    
    const int MaxN=500050;
    struct Edge{
    	int v;
    	int next;
    };
    Edge e[MaxN];
    int last[MaxN];
    int n,m,root,tot;
    int deep[MaxN];
    int f[MaxN];  
    
    void build(int x,int y){
    	tot++;
    	e[tot].v=y;
    	e[tot].next=last[x];
    	last[x]=tot;
    }
    
    //编号为x的节点,父亲是fa 
    void dfs(int x,int fa){
    	f[x]=fa;
    	deep[x]=deep[fa]+1;
    	for (int j=last[x]; j!=0; j=e[j].next){
    		int y=e[j].v;
    		if (y!=fa) dfs(y,x);		
    	}
    }
    
    
    int main(){
    	cin>>n>>root;
    	for (int i=1; i<=n-1; i++){
    		int x,y;
    		cin>>x>>y;
    		build(x,y);
    		build(y,x);
    	}
    	dfs(root,0);
    	for (int i=1; i<=n; i++) cout<<deep[i]<<" "; cout<<endl;
    	for (int i=1; i<=n; i++) cout<<f[i]<<" "; cout<<endl;	
    } 

    此种方法不仅适合二叉树,也适合多叉树。

    四、已知先序和中序遍历顺序,建立二叉树。

    LeetCode的题目:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/

    输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

    例如前序遍历 preorder = [3,9,20,15,7]
           中序遍历 inorder = [9,3,15,20,7]
    建立如下二叉树并返回根节点。
        3
       / \
      9  20
          /  \
       15   7

    思路就是递归分治。 对于一个先序遍历序列,第一个一定是根节点,如样例的3。我们只要在中序遍历序列中找到这个3,那么3之前的都是左子树,之后的都是右子树。再依次递归处理即可。
    因为题目说不含重复数字,所以在中序遍历中找根的这个工作可以借助哈希表。
    还要注意,因为我们递归的是中序遍历的序列,所以还要再加一个参数用来记录此序列的先序遍历第一个是谁,也就是根节点是谁。

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        unordered_map<int,int> h;
        TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
            int n=inorder.size();
            for (int i=0; i<n; i++) h[inorder[i]]=i; //哈希求位置
            TreeNode* head=build(preorder,inorder,0,n-1,0);//0~n-1 根是0
            return head;
        }
        TreeNode* build(vector<int>& preorder,vector<int>& inorder,int l,int r,int g){
            if (l>r) return NULL;
            TreeNode* t=new TreeNode(preorder[g]); //构造函数
            int j=h[preorder[g]]; //在inorder找pre[g]
            t->left=build(preorder,inorder,l,j-1,g+1);
            t->right=build(preorder,inorder,j+1,r,g+j-l+1);
            return t;
        }
    };

     

    展开全文
  • 先序递归建立二叉树

    2012-11-22 08:54:21
    用先序递归过程建立二叉树 (存储结构:二叉链表) 输入数据按先序遍历所得序列输入,当某结点左子树或右子树为空时,输入‘*’号
  • 层序创建二叉树,层序遍历二叉树

    千次阅读 2021-01-18 14:59:57
    G,先被访问的结点,他的孩子也是先被访问的,层序创建二叉树时,先创建的结点他的孩子也先创建,符合先进先出原则,因此可以用队列来实现。所以他们的共同点就是都可以用队列来帮助实现。 那就先从较为简单的遍历...

    在学习树的过程中发现,他们都有一个共同的特点,无论是在创建时还是遍历时,都是需要先父母再左孩子右孩子的顺序如图
    在这里插入图片描述
    层序遍历时顺序为A->B->C->D->E->F->G,先被访问的结点,他的孩子也是先被访问的,层序创建二叉树时,先创建的结点他的孩子也先创建,符合先进先出原则,因此可以用队列来实现。所以他们的共同点就是都可以用队列来帮助实现。
    那就先从较为简单的遍历开始吧!

    1.层序遍历

    思路:刚才分析时我们发现可用队列,第一步,若根节点不为空我们先让根节点入队,判断他的左右孩子是否为空,若不为空打印根节点并让他的孩子入队。
    第二步,取出队列中第一个结点并打印,判断他是否有左右孩子,若有让其孩子入队。
    重复第二步直到队列为空。
    代码:

    static void levelOrder(Node t){
            LinkedList<Node> q=new LinkedList();//声明队列
            q.add(t);//根节点入队应该判断一下根节点是否为空,没写懒了
            while(!q.isEmpty()) {
                Node p = q.pollFirst();//每次都取出对头结点
                System.out.print(p.data+" ");
                if(p.lchild!=null){//若有左孩子左孩子入队
                    q.add(p.lchild);
                }
                if(p.rchild!=null){//若有右孩子右孩子入队
                    q.add(p.rchild);
                }
            }
        }
    

    2.层序创建二叉树

    说实话我学习过程中没遇到过层序创建的,但是刷题遇见了一个输入是层序输入的,我当时就想层序怎么创建二叉树呢?其实和层序遍历差不多都是一个思想,先创建的他的孩子也先创建。

        //层序创建二叉树
        static Node cerate_LevelTree(Node node){
            LinkedList<Node> q=new LinkedList<Node>();//还是建个队列
            String ch;
            Node p;
            Scanner scanner=new Scanner(System.in);
            ch=scanner.nextLine();//从控制台取出输入第一个结点
            if(!ch.equals("null")){//若不为空则让他入队
                 node=new Node();//生成一个结点
                 node.data=ch;//把输入的数据存进去
                q.add(node);
            }
            while(!q.isEmpty()){
                ch=scanner.nextLine();//再从控制台取元素
                p=q.pollFirst();//每次都取出对头结点
                if(ch.equals("null")){//若不为空则证明有左孩子
                    p.lchild=null;
                }
                else{
                    p.lchild=new Node();//创建左孩子并入队
                    p.lchild.data=ch;
                    q.add(p.lchild);
                }
                ch=scanner.nextLine();//再取出一个元素
                if(ch.equals("null")){//若不为空则证明有右孩子
                    p.rchild=null;
                }
                else{
                    p.rchild=new Node();//创建右孩子并入队
                    p.rchild.data=ch;
                    q.add(p.rchild);
                }
            }
            return node;
        }
    

    根据代码,除了根节点都在while循环里,根据控制台输入的字符或者字符串先判断根节点有无左右孩子,若有则创建赋值并入队,若没有就让他的左孩子或者右孩子为空,如此循环往复,直到队列为空。

    展开全文
  • 定义二叉树的存储结构,由给定的一棵二叉树的先序序列和中序序列来创建二叉树,并输出二叉树的其它遍历序列
  • 二叉树创建C语言实现

    2018-02-24 15:07:59
    通过链式存储结构实现二叉树创建,包含如下操作: 1. 创建树; 2. 销毁树; 3. 清空树; 4. 插入结点; 5. 删除结点; 6. 获取结点; 7. 获取根结点; 8. 获取树的结点数; 9. 获取树的高度; 10. 获取树的度; 11...
  • 创建二叉树节点

    2015-03-04 10:54:00
    创建二叉树节点
  • C语言 创建二叉树及对二叉树的操作

    千次阅读 多人点赞 2020-10-22 11:16:17
    第一行 为自己输入的数据,在创建二叉树中数据域为char型,故空格和enter键也会被存入二叉树数据中。‘#’号总比二叉树数据结点多一个,不然一直在输入,无法进入输出。输出是中序遍历打印的。 根据上面的输入...
  • 题目描述 编一个程序,读入用户...可能有多组测试数据,对于每组数据,输出将输入字符串建立二叉树后中序遍历的序列,每个字符后面都有一个空格。每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b f
  • 数据结构——二叉链表创建二叉树(C语言版)

    万次阅读 多人点赞 2020-12-08 15:36:21
    数据结构——二叉链表创建二叉树一、思想(先序思想创建):二、创建二叉树(1)传一级参数方法 一、思想(先序思想创建): 第一步先创建根节点,然后创建根节点左子树,开始递归创建左子树,直到递归创建到的节点下...
  • 下面小编就为大家带来一篇java实现二叉树创建及5种遍历方法(总结)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 层次遍历创建二叉树

    千次阅读 2020-09-06 19:43:25
    #include <iostream>...//新定义二叉树类型 typedef ElementType int; //用0表示没有结点 #define NoInfo 0 struct TNode{ ElementType data; BinTree left; BinTree Right; }; BinTree
  • 非递归建立二叉树

    2020-05-05 13:45:24
    二叉树的实现
  • ##简单二叉树建立以及遍历 1.先序递归遍历创建二叉树 (1)二叉树的结点 class Node { //数据元素 public Object date; //左树 public Node leftchild; //右树 public Node righchild; public Node(){ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 157,301
精华内容 62,920
关键字:

创建二叉树