二叉树的遍历（前序遍历，中序遍历，后序遍历）

一、二叉树的遍历方式

        1、前序遍历

        2、中序遍历

        3、后序遍历

遍历思想：遍历二叉树采用递归的方式，首先要理解递归的思想。

遍历是要先判断根节点是否为空，如果不为空时，再向下遍历。

二叉树的遍历： 按某条搜索路径访问树中某个节点，树的每个节点均被访问依次，且只访问一次

先序遍历：先访问根，再访问左子树，再访问右子树 （根左右）
中序遍历：先访问左子树，在访问根，再访问右子树（左根右）
后序遍历：先访问左子树，再访问右子树，再访问根 （左右根）

下面先用C++把遍历思路展示：

1、二叉树的存储结构

typedef struct BiTNode {
		ElemType data;
		struct BiTNode *lchild,*rchild;
	}BiTNode,BiTree;

2、三种遍历如下

先序遍历的 递归算法:		//时间复杂度O(n)
	void PreOrder(BiTree T) {
		if(T!=NULL){
		Visit(T);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
		}
		}

中序遍历的递归算法：	//时间复杂度O(n)
	void InOrder(BiTree T){
		if(T!=NULL){
		InOrder(T->lchild);
		Visit(T);
		InOrder(T->rchild);
		}
	}

后序遍历的递归算法：
	void PostOrder(BiTree T){	//时间复杂度O（n）
		if(T!=NULL) {
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		Visit(T);
		}
	}

通过以上可以把遍历思想了解清楚

下面采用具体事例进行遍历：采用java  设置 5 个带编号的人物说明：

第一步：建立节点类

//创建节点
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //前序遍历
    public void preOrder()
    {
        System.out.println(this);
        if(this.left!=null)
            this.left.preOrder();
        if(this.right!=null)
            this.right.preOrder();
    }
    //中序遍历
    public void inOrder()
    {
        if(this.left!=null)
            this.left.inOrder();
        System.out.println(this);
        if(this.right!=null)
            this.right.inOrder();
    }
    //后续遍历
    public void postOrder()
    {
        if(this.left!=null)
            this.left.postOrder();
        if(this.right!=null)
            this.right.postOrder();
        System.out.println(this);
    }
}

第二步：创建二叉树类，调用遍历方法

//创建二叉树
class BinaryTree
{
    public HeroNode root;

   public void setRoot(HeroNode root)//建立根节点
   {
       this.root=root;
   }
//前序遍历
    public void perOrder()
    {
        if(this.root!=null)
        {
            this.root.preOrder();
        }else
            System.out.println("根节点空");
    }
    //中序遍历
    public void inOrder()
    {
        if(this.root!=null)
        {
            this.root.inOrder();
        }else
            System.out.println("根节点为空");
    }
    //后序遍历
    public void postOrder()
    {
        if(this.root!=null)
        {
            this.root.postOrder();
        }else
            System.out.println("根节点为空");
    }

}

第三步：创建二叉树对象，创建节点内容，连接各个节点，输出

class BinaryTree01 {
    public static void main(String[] args) {
        //创建二叉树
        BinaryTree B=new BinaryTree();

        //创建四个节点
        HeroNode n1=new HeroNode(1,"宋江");
        HeroNode n2=new HeroNode(2,"吴用");
        HeroNode n3=new HeroNode(3,"卢俊义");
        HeroNode n4=new HeroNode(4,"林冲");

        HeroNode n5=new HeroNode(5,"关胜");

        B.setRoot(n1);//设置根节点
        //连接节点
       n1.setLeft(n2);
       n1.setRight(n3);
       n3.setRight(n4);
       n3.setLeft(n5);


       B.perOrder();//前序遍历  1  2  3  4
        System.out.println("---------");
        B.inOrder();//中序遍历  2  1  3  4
        System.out.println("---------");
        B.postOrder();//后序遍历  2  4  3  1
    }
}

第四步：编译，执行

结果：

编译结果与预期的结果一致。