精华内容
下载资源
问答
  • 二叉树的顺序存储是指用一组地址连续的存储单元依次自上而下、自左向右存储完全二叉树上的结点元素 1 #include<stdio.h> 2 #include<stdlib.h> 3 typedef struct btree 4 { 5 int data; 6 ...

    二叉树的顺序存储是指用一组地址连续的存储单元依次自上而下、自左向右存储完全二叉树上的结点元素
    1
    #include<stdio.h> 2 #include<stdlib.h> 3 typedef struct btree 4 { 5 int data; 6 struct btree *right,*left; 7 8 }tree; 9 int s[1001],n; 10 void build_tree(tree* &t,int x)//建立二叉树,可以用引用也可以用二重指针 11 { 12 if(x>n||s[x]==0)//0或者超出元素就算结点为空 13 { 14 t=NULL; 15 return; 16 } 17 t=(tree*)malloc(sizeof(tree)); 18 t->data=s[x]; 19 build_tree(t->left,2*x); 20 build_tree(t->right,2*x+1); 21 } 22 int deep(tree* t)//树高 23 { 24 if(t==NULL) 25 return 0; 26 int l=0,r=0; 27 l=deep(t->left)+1; 28 r=deep(t->right)+1; 29 return l>r?l:r;//分别往左右两边遍历,比较两边最大的节点数就是树的高度。 30 } 31 void preorder(tree* t)//先序遍历 32 { 33 if(t) 34 { 35 printf(" %d",t->data); 36 preorder(t->left); 37 preorder(t->right); 38 } 39 } 40 void inorder(tree* t)//中序遍历 41 { 42 if(t) 43 { 44 inorder(t->left); 45 printf(" %d",t->data); 46 inorder(t->right); 47 } 48 } 49 void postorder(tree* t)//后序遍历 50 { 51 if(t) 52 { 53 postorder(t->left); 54 postorder(t->right); 55 printf(" %d",t->data); 56 } 57 } 58 int main() 59 { 60 tree *tr; 61 tr=NULL; 62 n=1; 63 while(scanf("%d",&s[n]))//先将数据入队,然后存入数组 64 { 65 if(s[n]==-1) 66 { 67 n--; 68 break; 69 } 70 n++; 71 } 72 build_tree(tr,1);//建立二叉树 73 preorder(tr); 74 printf("\n"); 75 inorder(tr); 76 printf("\n"); 77 postorder(tr); 78 printf("\n"); 79 return 0; 80 }

     

    转载于:https://www.cnblogs.com/AQhhhh/p/10844937.html

    展开全文
  • ( 1 )从键盘输入二叉树的结点信息,建立二叉树的存储结构; ( 2 )在建立二叉树的过程中按照二叉树先序方式建立。 2.依次使用二叉树的先根次序、中根次序、后跟次序遍历二叉树。 代码示例: import java.util....

    Java按先根序列建立二叉树并遍历二叉树

    例题:

    1.算法按先根序序列建立二叉树的二叉链表算法,按下列顺序读入字符: ABC##DE#G##F###

    ( 1 )从键盘输入二叉树的结点信息,建立二叉树的存储结构;

    ( 2 )在建立二叉树的过程中按照二叉树先序方式建立。

    2.依次使用二叉树的先根次序、中根次序、后跟次序遍历二叉树

    代码示例:

    
    import java.util.Scanner;
    
    public class Bnodept { //定义二叉树的存储结构
    	char data;
    	Bnodept lchild,rchild;
    	public Bnodept() {
    	}
    	public Bnodept(char data) {
    		this.data=data;
    		this.lchild=null;
    		this.rchild=null;
    	}
    	public Bnodept(char data,Bnodept lchild,Bnodept rchild) {
    		this.data=data;
    		this.lchild=lchild;
    		this.rchild=rchild;
    	}
    	Bnodept crt_bt_pre() { //先根序序列建立二叉树
    		char ch;
    		Bnodept bt;
    		System.out.println("从键盘输入一个字符:"); 
    		Scanner in=new Scanner(System.in);
    		String s1=in.nextLine();
    		ch=s1.charAt(0); //从键盘输入一个字符
    		if(ch=='#') { //'#'作为结束标志
    			return null;
    		}
    		else {
    			bt=new Bnodept(); //产生新结点
    			bt.data=ch;
    			bt.lchild=crt_bt_pre();
    			bt.rchild=crt_bt_pre();
    			return(bt);
    		}
    	}
    	static void preorder(Bnodept bt) { //先序遍历
    		if(bt!=null) { //为非空二叉树
    			System.out.print(bt.data+" "); //访问根结点
    			preorder(bt.lchild); //先根遍历左子树
    			preorder(bt.rchild); //先根遍历右子树
    		}
    	}
    	static void inorder(Bnodept bt) { //中序遍历
    		if(bt!=null) {
    			inorder(bt.lchild);
    			System.out.print(bt.data+" ");
    			inorder(bt.rchild);
    		}
    	}
    	static void postorder(Bnodept bt) { //后序遍历
    		if(bt!=null) {
    			postorder(bt.lchild);
    			  postorder(bt.rchild);
    			System.out.print(bt.data+" ");
    		}
    	}
    
    	public static void main(String[] args) {  //测试结果
    		Bnodept tree=new Bnodept();
    		Bnodept bt=tree.crt_bt_pre();
    		System.out.println("先序遍历:");  
    		preorder(bt);
    	    System.out.println();  
    	    System.out.println("中序遍历:");  
    	    inorder(bt);
    	    System.out.println();  
    	    System.out.println("后序遍历:");
    	    postorder(bt);	
    	}
    
    }

    运行截图:

    展开全文
  • 按照输入顺序建立二叉树 首先定义二叉树节点的结构体 typedef struct node{ int data; struct node* left; struct node* right; }Node;//一个结构体包含数据域,左右子树的指针 注意这里的左子树和右子树的数据...

    按照输入顺序建立二叉树
    首先定义二叉树节点的结构体

    typedef struct node{
    	int data;
    	struct node* left;
    	struct node* right;
    }Node;//一个结构体包含数据域,左右子树的指针
    

    注意这里的左子树和右子树的数据类型要设为指针

    主要思路:

    1.按顺序建立二叉树的过程实际上也可以看成是递归建立的过程;
    2.如果此时函数传入的参数是空节点(这里的空节点指的是节点对应的地址所指向的内容为空,即node=null)则为传入的节点分配存储空间,并将节点的左右孩子指针设置为空;(这一步实际上也是跳出递归的条件)
    3.如果传入的节点非空则递归建立左子树和右子树

    insert()

    void insert(Node* &node, int value){ //该函数形参的部分注意要加上引用符“&”,因为这一函数会使node指向的内容发生变化,是否加引用符的重要根据就是看指向的内容会不会发生变化
    	if(node == NULL){
    		node = (Node*)malloc(sizeof(Node)); //为node分配存储空间
    		node -> data = value; //节点的数据赋值为value
    		//下面这两步至关重要,因为递归的过程node的内容会不断变为原来node的left或right,而如果不赋值为null的话,当节点变为node->left或node->right时就无法判断该节点是否为空从而无法跳出递归
    		node -> left = NULL; 
    		node -> right = NULL;
    		return;
    	}
    	
    	insert(node -> left, value);  //递归建立左子树
    	insert(node -> right, value); //递归建立右子树
    }	
    

    main()函数

    int main(){
    	Node* node = NULL; //这节点里建立node节点并将其设置为null,目的是为了在传入insert函数时能够满足递归的边界条件,否则传入后将无法继续执行下去
    	int n;
    	scanf("%d", &n);
    	for(int i = 0; i < n; i++){
    		int temp;
    		scanf("%d", &temp);
    		insert(node, temp);
    	}
    	inorder(node); //中序输出每个节点,验证是否正确
    	return 0;
    }
    

    全部代码

    #include <stdio.h>
    #include <cstdlib>
    
    typedef struct node{
    	int data;
    	struct node* left;
    	struct node* right;
    }Node;
    
    typedef struct{
    	Node* root;
    }Tree;
    
    void insert(Node* &node, int value){ //该函数形参的部分注意要加上引用符“&”,因为这一函数会使node指向的内容发生变化,是否加引用符的重要根据就是看指向的内容会不会发生变化
    	if(node == NULL){
    		node = (Node*)malloc(sizeof(Node)); //为node分配存储空间
    		node -> data = value; //节点的数据赋值为value
    		//下面这两步至关重要,因为递归的过程node的内容会不断变为原来node的left或right,而如果不赋值为null的话,当节点变为node->left或node->right时就无法判断该节点是否为空从而无法跳出递归
    		node -> left = NULL; 
    		node -> right = NULL;
    		return;
    	}
    	
    	insert(node -> left, value);  //递归建立左子树
    	insert(node -> right, value); //递归建立右子树
    }		
    
    
    void inorder(Node* node){
    	printf("%d", node->data);
    	if(node){
    		
    		inorder(node -> left);
    		printf("%d", node->data);
    		inorder(node -> right);
    	}
    }
    
    int main(){
    	Node* node = NULL; //这节点里建立node节点并将其设置为null,目的是为了在传入insert函数时能够满足递归的边界条件,否则传入后将无法继续执行下去
    	int n;
    	scanf("%d", &n);
    	for(int i = 0; i < n; i++){
    		int temp;
    		scanf("%d", &temp);
    		insert(node, temp);
    	}
    	inorder(node); //中序输出每个节点,验证是否正确
    	return 0;
    }
    
    展开全文
  • //用vector建立堆栈 template class Stack  {  public:   void Push( const T& t ) { elements.insert( elements.begin(), t ); }   T Pop() { T tmp = *(elements.begin());   
    BiTree.h
    #include <vector> 
    //用vector建立堆栈
    
    
    template <class T>  
    class Stack  
    {  
    public:  
        void Push( const T& t ) { elements.insert( elements.begin(), t ); }  
        T Pop() { T tmp = *(elements.begin());  
                elements.erase( elements.begin() ); return tmp;  }  
        bool IsEmpty() { return elements.empty(); }  
        T Top() { return *(elements.begin()); }  
      
    private:  
        std::vector<T> elements;  
    };  
    
    
    //将结点存储在二叉链表中
    struct BiTNode{
        char data;    //链表中存储的数据
        struct BiTNode *lchild, *rchild;//左右孩子  
    };
    
    
    void CreateBiTree(BiTNode* &T);    //根据先序输入建树
    void PreOrderTraverse(BiTNode* &T);//递归先序遍历
    void Inorder(BiTNode* &T);         //递归中序遍历
    void Posorder(BiTNode* &T);        //递归后序遍历
    
    
    void PreorderDump(BiTNode* &T);    //非递归先序遍历
    void InorderDump(BiTNode* &T);     //非递归中序遍历
    void PostOrderDump(BiTNode* &T);   //非递归后序遍历
    
    BiTreeImp.cpp
    #include "BiTree.h"
    
    
    void CreateBiTree(BiTNode* &T)
    {
        char ch;
        if ((ch = getchar()) == ' ')
            T = NULL;//其中getchar()为逐个读入标准库函数  
        else
    	{
            T = new BiTNode;//产生新的子树  
            T->data = ch;//由getchar()逐个读入来  
            CreateBiTree(T->lchild);//递归创建左子树  
            CreateBiTree(T->rchild);//递归创建右子树  
        }
    }
    
    
    void PreOrderTraverse(BiTNode* &T)
    {
        if (T)
    	{//当结点不为空的时候执行  
            cout << T->data;
    
    
            PreOrderTraverse(T->lchild);
            PreOrderTraverse(T->rchild);
        }
    }
    
    
    void Inorder(BiTNode* &T)
    {
        if (T)
    	{
            Inorder(T->lchild); 
    
    
            cout << T->data;  
    
    
            Inorder(T->rchild);
        }
    }
    
    
    void Posorder(BiTNode* &T)
    {
        if (T)
    	{
            Posorder(T->lchild);
            Posorder(T->rchild);
            cout << T->data;
        }
    }
    
    
    void PreorderDump(BiTNode* &T)  
    {  
        BiTNode* p = T;  
        Stack<BiTNode*> stack;  
    
    
        while( p != NULL || !stack.IsEmpty() )  
        {  
            while ( p != NULL )  
            {  
    			cout << p->data;  
                stack.Push(p);  
    			p = p->lchild;  
            }  
      
            if ( !stack.IsEmpty() )  
            {  
                p = stack.Pop();  
    			p = p->rchild;  
            }  
        }  
      
    }  
    
    
    void InorderDump(BiTNode* &T)  
    {  
        BiTNode* p = T;  
        Stack<BiTNode*> stack;  
    
    
        while( p != NULL || !stack.IsEmpty() )  
        {  
            if ( p != NULL )  
            {  
                stack.Push(p); // if has left tree  
    			p = p->lchild;  
            }  
            else // left tree traversed  
            {  
                p = stack.Pop();  
    			cout << p->data;
    			p = p->rchild;  
            }  
        }  
      
    }  
    
    
    void PostOrderDump(BiTNode* &T)  
    {  
        BiTNode* p = T;  
    	BiTNode* pPre = NULL;
        Stack<BiTNode*> stack;  
    
    
        while( p != NULL || !stack.IsEmpty() )  
        {  
          if ( p != NULL )  
            {  
                stack.Push( p ); // if has left tree  
    			p = p->lchild;  
            }  
            else   
            {  
                p = stack.Top();  
    			if ( p->rchild != NULL && pPre != p->rchild )   
                {  
    				p = p->rchild;  
                }  
                else  
                {  
                    p = pPre = stack.Top(); 
    				cout << p->data;
                    stack.Pop();  
                    p = NULL;  
                }  
            }  
        }  
      
    }  
    
    BiTree.cpp
    #include <iostream>  
    using namespace std;
    #include "BiTreeImp.cpp"
    
    
    BiTNode* T;    //定义一个二叉树
    
    
    int main(){
    
    
        cout << "Please put the test data in: " << endl;
        CreateBiTree(T);
    
    
        cout << "先序递归遍历:" << endl;
        PreOrderTraverse(T);
        cout << endl;
    
    
        cout << "中序递归遍历:" << endl;
        Inorder(T);
        cout << endl;
    
    
        cout << "后序递归遍历:" << endl;
        Posorder(T);
        cout << endl;
    
    
    	cout << "先序非递归遍历:" << endl;
        PreOrderTraverse(T);
        cout << endl;
    
    
        cout << "中序非递归遍历:" << endl;
        Inorder(T);
        cout << endl;
    
    
        cout << "后序非递归遍历:" << endl;
        Posorder(T);
        cout << endl;
    
    
    	system("pause");
        return 1;
    }
    
    参考:http://blog.csdn.net/cristina_song/article/details/78543077

    展开全文
  • 最简单的二叉树建立的程序,比较适合初学者,可作为初学者的树与二叉树的第一个程序!
  • 先序中序建立二叉树 急~~ 1二叉树中存储的数据范围仅限于26个英文字母 2程序要提示用户从键盘分别输入二叉树的先序和中序序列接受输入后调用相应的函数完成二叉树的创建 3成功创建二叉树后程序自动输出该二叉树的...
  • 先序中序建立二叉树

    千次阅读 2012-04-10 10:34:43
    2程序要提示用户从键盘分别输入二叉树的先序和中序序列,接受输入后,调用相应的函数完成二叉树的创建 3成功创建二叉树后,程序自动输出该二叉树的后序遍历次序 #include #include #include #define ...
  • [问题描述] 建立二叉树,并输出二叉树的先序,中序和后序遍历序列,以及二叉树的叶子数。 [基本要求] 要求根据读取的元素建立二叉树,能输出各种遍历。 [实现提示] 可通过输入带空格的前序序列建立二叉链表。
  • 编一个程序,读入用户输入的一串先序遍历字符串,根据此字符串建立一个二叉树(以指针方式存储)。 例如如下的先序遍历字符串: ABC##DE#G##F### 其中“#”表示的是空格,空格字符代表空树。建立起此二叉树以后,再...
  • 输入二叉树的扩展先序序列,以二叉链表作为存储结构,建立二叉树。 输出这棵二叉树的先序、中序和后序遍历序列,其中后序遍历使用非递归算法实现。 统计二叉树中非叶子结点的个数。 计算二叉树的高度。 非递归后序...
  • 从键盘输入一个字符,判断其是否为空字符,本代码用’#'代替空字符。如果是,则该节点赋值NULL;如果不是,则该节点的数据域data赋值为该字符,同时调用函数自身,传入左孩子指针,继续调用函数自身,传入右孩子指针...
  • 用括号法递归建立二叉树

    千次阅读 2018-06-21 00:02:26
    描述如果用大写字母...如一棵二叉树可表示为:A(B(#,D),C(E(#,F),#)) 输入按题中要求,用括号法输入二叉树序列,#表示空节点 输出按层次遍历建立好的二叉树并输出 输入样例A(B(#,D),C(E(#,F),#)) 输出样例ABC...
  • //str是二叉树的广义表表示的字符串     //st是栈空间,b是新建二叉链表的根指针    BTNode *St[MaxSize],*P = NULL,*b;   int  top = -1,k,j = 0;   char  ch;  ch = str[j];   //初始化...
  • “遍历”是二叉树各种操作的基础,假设访问结点的具体操作不仅仅局限于输出结点数据域的值,而是把“访问”延伸到对结点的判别、计数等其他操作,可以解决一些关于...(1)从键盘输入二叉树的结点信息,建立二叉树的...
  • 二叉树建立与遍历

    2014-07-01 18:17:07
    以树为研究对象,实现从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),并采用递归算法对其进行遍历(先序、中序、后序),将遍历结果打印输出的功能,又增加了选作内容实现了利用非...
  • 如果用大写字母标识二叉树结点,则一棵二叉树可以用符合下面语法图的字符序列标识,试编写递归程序,由这种形式的字符序列,建立相应的二叉树的二叉链表存储结构(附图见《严蔚敏:数据结构题集(C语言版)》第45页...
  • 建立二叉树的二叉链表存储结构实现以下操作(选择其中的两个做) (1)输出二叉树 (2)先序遍历二叉树 (3) 中序遍历二叉树 (4)后序遍历二叉树 (5)层次遍历二叉树
  • 先序遍历:若二叉树为空,则空操作;否则访问根节点;先序遍历左子树;先序遍历右子树。 中序遍历:若二叉树为空,则空操作;否则中序遍历左子树;访问根节点;中序遍历右子树。/* * Created by Microsoft Visual ...
  • 二叉树建立

    2014-06-06 18:16:10
    二叉树建立,利用左右孩子指针,查找节点并求指定节点路径
  • 从键盘接收扩展先序序列,以二叉链表作为存储结构,建立二叉树。按先序遍历次序输出各结点的内容及相应的层次数,要求以二元组的形式输出,其所对应的输出结果为:(data,level) data是二叉树结点数据域值,level是...
  • 从键盘输入先序序列,以二叉链表作为存储结构, 建立二叉树(以先序来建立)并对其进行遍历(先序、中序、后序), 然后将遍历结果打印输出。`在这里插入代码片` 要求采用递归和非递归两种方法实现。 输入样例: ...
  • 输入若干数据,以任意字母结束,以此数据建立有序二叉树,并先序遍历输出。
  • 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如,给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树: 3 / \ 9 20 / ...
  • 二叉树建立
  • 3. 主程序中,分别输入两个字符串,作为二叉树的先序和中序序列; 两个子函数分别实现创建二叉树和后序遍历输出二叉树的功能。而在子函数中还调用了例如出栈入栈等子函数。*/ #include #include #include #...
  • 关于不建立这棵二叉树来求解这棵树的后序序列,可以这么考虑:其实求解一棵二叉树的后序序列等价于求解左子树的后序序列+右子树的后序序列+根节点,这是一个递归的考虑过程。
  • 首先本次代码实现的是将已经定义好的数值按二叉树的前序、中序、后序输出(非键盘直接输入!!!!) 本人用到的编辑软件是Mac的Xcode下的C++文件编写,如果用Xcode C文件写时引用(&)方法不能识别,windows...
  • 从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),并采用递归算法对其进行遍历(先序、中序、后序),将遍历结果打印输出。 3.测试要求: ABCффDEфGффFффф(其中ф表示空格...
  • 建立一个简单二叉树的基本步骤

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,733
精华内容 1,493
热门标签
关键字:

从键盘输入建立二叉树