写出下图所示二叉树进行先序遍历、中序遍历、后序遍历时得到的顶点序列。

写出二叉树的先序遍历、中序遍历、后序遍历。~

//二叉树的节点结构
class TreeNode {
int Id=0;
String data=null;
boolean isVisted=false;
TreeNode leftChild=null;
TreeNode rightChild=null;
public TreeNode(){}
public TreeNode(int Id,String data){
this.Id=Id;
this.data=data;
this.leftChild=null;
this.rightChild=null;
}
}
[java] view plain copy
[java] view plain copy
import java.util.Stack;
public class firstBinaryTree {
private TreeNode root=null;
//构造方法
public firstBinaryTree(){
root=new TreeNode(1,"rootNode");
}
//创建二叉树
protected void createBT(TreeNode root){
TreeNode NodeB= new TreeNode(2,"B");
TreeNode NodeC= new TreeNode(3,"C");
TreeNode NodeD= new TreeNode(4,"D");
TreeNode NodeE= new TreeNode(5,"E");
TreeNode NodeF= new TreeNode(6,"F");
TreeNode NodeG= new TreeNode(7,"G");
TreeNode NodeH= new TreeNode(8,"H");
TreeNode NodeI= new TreeNode(9,"I");
root.leftChild=NodeB;
root.rightChild=NodeC;
NodeB.leftChild=NodeD;
NodeB.rightChild=NodeE;
NodeC.leftChild=NodeF;
NodeC.rightChild=NodeG;
NodeD.leftChild=NodeH;
NodeE.rightChild=NodeI;
}
//判断为空
public boolean isEmpty(){
return root==null;
}
//前序非递归遍历
private void preOrederNotR(TreeNode p){
Stack stack = new Stack();
TreeNode node=p;
while(node!=null || stack.size()>0){
while(node!=null){
visted(node);
stack.push(node);
node=node.leftChild;
}
if(stack.size()>0){
node=stack.peek();
node=node.rightChild;
stack.pop();
}
}
}
//中序非递归遍历
private void inOrederNotR(TreeNode p){
Stack stack = new Stack();
TreeNode node=p;
while(node!=null || stack.size()>0){
while(node!=null){
stack.push(node);
node=node.leftChild;
}
if(stack.size()>0){
node=stack.pop();
visted(node);
node=node.rightChild;
}
}
}
//后序非递归遍历
private void lastOrederNotR(TreeNode p){
Stack stack = new Stack();
TreeNode node=p;
while(p!=null){
//左子树入栈
while(p.leftChild!=null){
stack.push(p);
p=p.leftChild;
}
//当前结点无右子树或右子树已经输出
while(p.rightChild==null||p.rightChild==node){
visted(p);
node =p; //记录上一个已输出结点
if(stack.empty())
return;
p=stack.pop();
}
//右子树进栈
stack.push(p);
p=p.rightChild;
}
}
//前序遍历
private void preOrder(TreeNode subTree) {
// TODO Auto-generated method stub
if(subTree!=null){
visted(subTree);
preOrder(subTree.leftChild);
preOrder(subTree.rightChild);
}
}
//中序遍历
private void inOrder(TreeNode subTree) {
// TODO Auto-generated method stub
if(subTree!=null){
inOrder(subTree.leftChild);
visted(subTree);
inOrder(subTree.rightChild);
}
}
//后序遍历
private void lastOrder(TreeNode subTree) {
// TODO Auto-generated method stub
if(subTree!=null){
lastOrder(subTree.leftChild);
lastOrder(subTree.rightChild);
visted(subTree);
}
}
//访问该节点
private void visted(TreeNode subTree) {
// TODO Auto-generated method stub
subTree.isVisted=true;
System.out.println("ID:"+subTree.Id+"name:"+subTree.data);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
firstBinaryTree bt= new firstBinaryTree();
bt.createBT(bt.root);
bt.preOrder(bt.root);
bt.preOrederNotR(bt.root);
System.out.println("------------------------------");
bt.inOrder(bt.root);
bt.inOrederNotR(bt.root);
System.out.println("--------------------------------");
bt.lastOrder(bt.root);
bt.lastOrederNotR(bt.root);
}
}

前序遍历的结点序列是：BEFCGDH；中序遍历的结点序列是：FEBGCHD；后序遍历的结点序列是：FEGHDCB。
前序遍历首先访问根结点然后遍历左子树，最后遍历右子树；序遍历首先遍历左子树，然后访问根结点，最后遍历右子树；后序遍历先左后右再根，即首先遍历左子树，然后遍历右子树，最后访问根结点。

扩展资料：
结点是包括一个数据元素及若干个指向其它子树的分支；例如，A，B，C，D等。
在数据结构的图形表示中，对于数据集合中的每一个数据元素用中间标有元素值的方框表示，一般称之为数据结点，简称结点。
在C语言中，链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据；二为下一个结点的地址，即指针域和数据域。
数据结构中的每一个数据结点对应于一个储存单元，这种储存单元称为储存结点，也可简称结点。

先序遍历序列: A B D C E

中序遍历序列: B D A E C

后序遍历序列: D B E C A

       A
     /    \
    B      C
     \    / 
      D  E 


//C语言测试程序

#include "stdio.h"
#include "stdlib.h"
struct tree
{
    char data;
    struct tree *left;
    struct tree *right;
};
typedef struct tree treenode;
typedef treenode *btree;

btree createbtree(char *data,int pos,int maxPos) //递归创建法
{
    btree newnode;

    if(data[pos]==0 || pos>maxPos)
    {
        return NULL;
    }
    else
    {
        newnode=(btree)malloc(sizeof(treenode));
        newnode->data=data[pos];
        newnode->left=createbtree(data,2*pos,maxPos);
        newnode->right=createbtree(data,2*pos+1,maxPos);
        return newnode;
    }
}

void inorder(btree ptr)
{
    if(ptr!=NULL)
    {
        inorder(ptr->left);
        printf("%C ",ptr->data);
        inorder(ptr->right);
    }
}

void preorder(btree ptr)
{
    if(ptr!=NULL)
    {
        printf("%C ",ptr->data);
        preorder(ptr->left);
        preorder(ptr->right);
    }
}

void postorder(btree ptr)
{
    if(ptr!=NULL)
    {
        postorder(ptr->left);
        postorder(ptr->right);
        printf("%C ",ptr->data);
    }
}

int main()
{
    btree root=NULL;
    int i;

    char data[16]={0,'A','B','C',0,'D','E',0,
                   0,0,0,0,0,0,0,0};
    root=createbtree(data,1,15);
    printf("二叉树的顺序存储内容: ");
    for(i=1;i<16;i++)
    {
        if(data[i]==0)
        {
            printf("^ ");
        }
        else
        {
            printf("%c ",data[i]);
        }
    }

    printf("
二叉树的先序遍历序列: ");
    preorder(root);
    printf("
二叉树的中序遍历序列: ");
    inorder(root);
    printf("
二叉树的后序遍历序列: ");
    postorder(root);

    printf("
");
    return 0;
}

为什么二叉树的遍历先根后叉?
答：先序遍历也叫做先根遍历、前序遍历，可记做根左右（二叉树父结点向下先左后右）。首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树，如果二叉树为空则返回。例如，下图所示二叉树的遍历结果是：ABDECF。

已知某二叉树的中序遍历序列为CBGEAFHD,后序遍历序列为CGEBHFDA,试写 ...
答：A是整个树的根，CBGE为左子树，FHD为右子树 CBGE中B为根，C为左子树，GE为右子树 FHD中D为根，FH为左子树，无右子树 GE中E为根，G为左子树，无右子树 FH中F为根，无左子树，H为右子树 前序结果为 ABCEGDFH

二叉树前序中序后序口诀
答：二叉树前序中序后序口诀：前序遍历:根节点—-左子树—-右子树，中序遍历:左子树—-根节点—-右子树，后序遍历:左子树—-右子树—-根节点 先序：是二叉树遍历中的一种，即先访问根结点，然后遍历左子树，后遍历右子树。遍历左、右子树时，先访问根结点，后遍历左子树，后遍历右子树，如果二叉树...

11.已知一颗二叉树如下图所示,试分别写出按中序、先序和后序遍历时所...
答：先序 a i d h b x p f r 中序 d i a x b p h f r 后序 d i x p h r f h a

一颗二叉树的先序遍历结果和中序遍历结果分别是ABDECFG、DBEAFGC...
答：先序遍历中的第一个字母A就是二叉树的根结点，A，在中序遍历中找到A，他的左侧有三个字母DBE就是它的左子树的中序遍历，然后再先序便利中同样找到A后面的三个字母BDE，就是根结点的左子树的先序遍历。用同样的方法找出根结点的右子树的前序遍历和中序遍历，然后递归使用前面的方法就可以画出整个...

构造一棵二叉树,并分别输出其先序遍历、中序遍历和后序遍历的结果
答："<<endl;CreateBiTree(T);cout<<"二叉树的先序遍历为:"<<endl;preBiTree(T);cout<<endl;cout<<"二叉树的中序遍历为:"<<endl;InBiTree(T);cout<<endl;cout<<"二叉树的后序遍历为:"<<endl;PostBiTree(T);cout<<endl;cout<<"二叉树的深度为:"<<endl;cout<<Depth(T)<<endl;} ...

建立二叉链表存储下图所示的二叉树,并用递归算法对其进行前序、中序...
答：include<stdio.h> include<stdlib.h> typedef struct bitnode { char data;struct bitnode *lchild,*rchild;}bitnode,*bitree;//二叉树节点类型和节点指针类型 bitree create()//先序创建 { bitree root=NULL;char c;scanf("%c",&c);fflush(stdin);if(c=='#')return NULL;else { root=(...

数据结构,某二叉树前序遍历ABCDEFG,中序遍历CBDAEFG,求后序遍历及一般...
答：先看前序遍历的，找到根a,然后看中序遍历找到左子树(cbd),右子树(efg),之后看前序，找到根b，再看中序遍历，b为左，d为右，右子树同理，前序遍历知e为根，中序遍历知，fg为右，前序遍历知f为根，g为右。所以整棵树如下：a b e c d f g 后序遍历为cdbgfea ...

根据先序和中序,画出二叉树
答：二叉树示意图: A / \ B F / \ \ E C G \ / \ D H J \ I先序遍历序列: ABECDFGHIJ中序遍历序列: EBCDAFHIGJ后序遍历序列: EDCBIHJGFA//C语言测试程序#include "stdio.h"#include "stdlib.h"struct tree{ char data; ...

已知一棵二叉树的先序遍历序列为ABCDEFGHIJ,中序遍历序列为CBDEAFHIGJ...
答：接着先序中是F，F在中序为A后面，是A的右子树 A / \ B F / \ C D \ E 中序中 A 与F之间没有，说明F没有左子树，只有右子树.如上面方法继续分析GHIJ，最终二叉树如下：A / \ B F / \ \ C D G \ / \ E H J \ I ...