数据结构8--二叉树的历遍（java代码实现二叉树的遍历）

本篇博客主要基于二叉树的创建上实现对二叉树的遍历

1.二叉树的遍历

    二叉树的遍历是指以某种次序访问二叉树中的所有节点，并且使每个节点恰好只被访问一次。

    遍历的方式有三种：

   1.先序遍历：

    先序遍是历先访问根节点

    访问左子树

    访问右子树

     

  2.中序遍历

    中序遍历是把根节点的遍历放在中间

   

3.后序遍历：

  后序遍历是把根节点放在最后历遍

   

   2.java代码实现这三种遍历方式

          创建一棵树的代码在上一篇博客已经实现，这里还是再贴一遍代码

     创建一个树的节点类：

   

package com.wx.datastructure.base;
/*
   这是一个树的节点，包含三个部分，左指针，又指针和数据域
 */
public class TreeNode {
    public TreeNode left,right;
    public Object value;
    public TreeNode(TreeNode left,TreeNode right,Object value)
    {
          this.left=left;
          this.right=right;
          this.value=value;
    }
    public TreeNode(Object value)
    {
        this(null,null,value);
    }
    public TreeNode()
    {
        this(null,null,null);
    }
    //判断是不是叶子节点
    public boolean isLeaf()
    {
        if (this.left==null&&right==null)
        {
            return true;
        }
        return  false;
    }
    //重写toString()方法
    public String toString()
    {
        String res="";
        if (this.value==null)
        {
            return "";
        }
        res+=this.value;
        if (this.left!=null)
        {
            res+=","+left.toString();
        }
        if (this.right!=null)
        {
            res+=","+right.toString();
        }
        return res;
    }
}

 创建一个二叉树类，并实现遍历的方法：

package com.wx.datastructure.base;

import java.util.ArrayList;
import java.util.Vector;
/*
    二叉树类
 */
public class TwoForkedTree {
    private TreeNode root;
    public TwoForkedTree()
    {
        root=null;
    }
    public TwoForkedTree(TreeNode node)
    {

        this.root=node;
    }
    //判断二叉树是否为空
    public boolean isEmpty()
    {
        if (root==null)
        {
            return true;
        }
      return false;
    }
     /*
    先序历遍
     */
     private static Vector firstRoot(TreeNode root)
     {
          Vector result=new Vector();
          if (root==null)
          {
              return result;
          }
          //先序遍历是先要访问根节点
         result.add(root);
         //其次访问左子树，先访问左子树的根,recursive call 递归调用
         Vector leftChild = firstRoot(root.left);
         //然后访问右子树
         Vector rightChild = firstRoot(root.right);
         //将左右子树的序列按顺序插入
         result.addAll(leftChild);
         result.addAll(rightChild);
         return result;
     }
     //提供一个先序遍历只对外输出value的方法
     public static ArrayList<String> getFirstRoot(TreeNode root)
     {
         Vector vector1 = TwoForkedTree.firstRoot(root);
         ArrayList<String> list =new ArrayList<String>();
         list.add(vector1.get(0).toString());
         return list;
     }

     /*
     中序遍历
      */
     public static Vector midRoot(TreeNode root)
     {
         Vector result=new Vector();
         if (root==null)
         {
             return result;
         }
         //中序遍历就是把根节点放在中间访问，所以首先访问根节点的左子树
         Vector leftChild = midRoot(root.left);
         result.addAll(leftChild);  // AddAll是传入一个List，将此List中的所有元素加入到当前List中，也就是当前List会增加的元素个数为传入的List的大小
         //然后中间访问根节点
         result.add(root);//  Add方法是将传入的参数作为当前List中的一个item存储，即使你传入一个List也只会令当前的List增加1个元素
         //最后访问右子树
         Vector rigthChild = midRoot(root.right);
         result.addAll(rigthChild);
         return result;
     }
    //提供一个中序遍历只对外输出value的方法
    public static ArrayList<String> getMidRoot(TreeNode root)
    {
        Vector vector1 = TwoForkedTree.midRoot(root);
        ArrayList<String> list =new ArrayList<String>();
        for (int i=0;i<vector1.size();i++)
        {
            //System.out.println(vector1.get(i).toString().trim());
          //  System.out.print(vector1.get(i).toString().trim().substring(0,1));
            list.add(vector1.get(i).toString().trim().substring(0,1));
        }
        return list;
    }
     /*
      后序遍历
      */
     public static Vector lastRoot(TreeNode root)
     {
         Vector result=new Vector();
         if (root==null)
         {
             return result;
         }
         //后序遍历就是最后才访问根节点
         //所以先要访问左子树
         Vector leftChild = lastRoot(root.left);
         result.addAll(leftChild);
         //然后访问右子树
         Vector rightChild = lastRoot(root.right);
         result.addAll(rightChild);
         //最后访问根节点
         result.add(root);
         return  result;
     }
    //提供一个后序遍历只对外输出value的方法
    public static ArrayList<String> getLastRoot(TreeNode root)
    {
        Vector vector1  = TwoForkedTree.lastRoot(root);
        ArrayList<String> list =new ArrayList<String>();
        for (int i=0;i<vector1.size();i++)
        {
            String s = vector1.get(i).toString().trim().substring(0, 1);
            list.add(s);
        }
        return list;
    }
}

 测试：

package com.wx.datastructure.test;

import com.wx.datastructure.base.TreeNode;
import com.wx.datastructure.base.TwoForkedTree;

import java.util.ArrayList;
import java.util.Vector;

public class TestTwoforkedtree {
    public static void main(String[] agrs)
    {
        //构造一棵二叉树,结构如图：
        /*
                  a
               b     c
             d  e   f   g
         */
        TreeNode nodeD=new TreeNode("d");
        TreeNode nodeE=new TreeNode("e");
        TreeNode nodeF=new TreeNode("f");
        TreeNode nodeG=new TreeNode("g");
        TreeNode nodeB=new TreeNode(nodeD,nodeE,"b");
        TreeNode nodeC=new TreeNode(nodeF,nodeG,"c");
        TreeNode rootA=new TreeNode(nodeB,nodeC,"a");
        TwoForkedTree tree=new TwoForkedTree(rootA);

        /*
        先序遍历
        输出结果：a,b,d,e,c,f,g
         */
        ArrayList<String> firstRoot = TwoForkedTree.getFirstRoot(rootA);
        System.out.print("先序遍历:");
        for (int i=0;i<firstRoot.size();i++)
        {
            System.out.println(firstRoot.get(i));
        }
        /*
        中序遍历 d,b,e,a,f,c,g
         */
        ArrayList<String> midRoot = TwoForkedTree.getMidRoot(rootA);
        System.out.print("中序遍历:");
        for (int i=0;i<midRoot.size();i++)
        {
            System.out.print(midRoot.get(i)+" ");
        }
        /*
        后序遍历 d,e,b,f,g,c,a
         */
        ArrayList<String> lastRoot = TwoForkedTree.getLastRoot(rootA);
        System.out.println("");
        System.out.print("后序遍历:");
        for (int i=0;i<lastRoot.size();i++)
        {
            System.out.print(lastRoot.get(i)+" ");
        }

    }

}

  结果：ok 是我们想要的结果，接下来会继续学习数据结构中的图。。。