本篇博客主要基于二叉树的创建上实现对二叉树的遍历
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 是我们想要的结果,接下来会继续学习数据结构中的图。。。