一般二叉树的创建,前序,中序,后序遍历

二叉树的前序,中序,后序遍历顺序,可以理解成是以根节点的访问顺序来定义的,

比如:

前序遍历:根节点,左子树节点,右子树节点,

中序遍历:左子树节点,根节点,右子树节点,

后序遍历:左子树节点,右子树节点,根节点

 

先创建一个Node类来存储节点的值,左子树和右子树

 1 package tree;
 2 
 3 public class Node {
 4     //也可以将其节点定义为内部类
 5             public Node right; //右子树节点
 6             public Node left;    //左子树节点
 7             public int date;    //该节点存放的值
 8             Node(int newdate){
 9                 right=null;
10                 left=null;
11                 date=newdate;
12             }
13 
14 }

一般二叉树的实现类

  1 package tree;
  2 
  3 import java.util.LinkedList;
  4 import java.util.List;
  5 
  6 public class Tree {
  7     //给一个默认的数组来构建二叉树
  8     private int[] array= {1,2,3,4,5,6,7,8,9};
  9     //声明一个Node类型的list集合来存储二叉树的结构
 10     private static List<Node> nodelist=null;
 11 //    //将节点定义为内部类,因为在其它类中也需要使用到这个Node类,为了方便就不定义成内部类了
 12 //        private static class Node{
 13 //            Node right;
 14 //            Node left;
 15 //            int date;
 16 //            Node(int newdate){
 17 //                right=null;
 18 //                left=null;
 19 //                date=newdate;
 20 //            }
 21 //        }
 22     public void createTree() {
 23         //创建一个双链表作为队列
 24         nodelist=new LinkedList<Node>();
 25         //将数组的值全部转换为Node节点
 26         for(int nodelistIndex=0;nodelistIndex<array.length;nodelistIndex++ ) {
 27             nodelist.add(new Node(array[nodelistIndex]));
 28         }
 29         /***
 30          *           1
 31          *         /   \
 32          *        2     3
 33          *       /\     /\
 34          *      4  5   6  7
 35          */
 36         for(int parentIndex=0;parentIndex<(array.length/2-1);parentIndex++) {
 37             //左孩子节点
 38             nodelist.get(parentIndex).left=nodelist.get(parentIndex*2+1);
 39             //右孩子节点
 40             nodelist.get(parentIndex).right=nodelist.get(parentIndex*2+2);
 41         }
 42         /***
 43          *           1
 44          *         /   \
 45          *        2     3
 46          *       /\     /\
 47          *      4  5   6  7
 48          *     / \
 49          *    8   9
 50          */
 51         //最后一个父节点可能只有左孩子节点没有右孩子节点
 52         int lastParentIndex=array.length/2-1;
 53         nodelist.get(lastParentIndex).left=nodelist.get(lastParentIndex*2+1);
 54         //如果array的数组长度为奇数,则最后一个父节点有右孩子节点
 55         if(array.length%2==1) {
 56             nodelist.get(lastParentIndex).right=nodelist.get(lastParentIndex*2+2);
 57         }
 58     }
 59     /**
 60      *     使用递归的方式来遍历二叉树
 61      * @param node
 62      */
 63     //先序遍历---》根节点,左节点,右节点
 64     public static void preOrdertraverse(Node node){
 65         if(node==null) return;
 66         System.out.print(node.date+"-");
 67         preOrdertraverse(node.left);
 68         preOrdertraverse(node.right);
 69     }
 70     //中序遍历---》左节点,根节点,右节点
 71     public static void inOrdertraverse(Node node) {
 72         if(node==null)return;
 73         inOrdertraverse(node.left);
 74         System.out.print(node.date+"-");
 75         inOrdertraverse(node.right);
 76     }
 77     //后序遍历---》左节点,右节点,根节点
 78     public static void postOrdertraverse(Node node) {
 79         if(node==null) return;
 80         postOrdertraverse(node.left);
 81         postOrdertraverse(node.right);
 82         System.out.print(node.date+"-");
 83     }
 84     /**
 85      *     得到二叉树的根节点,用作遍历的始节点
 86      *     
 87      * @return
 88      */
 89     public Node getNodelist() {
 90         return nodelist.get(0);
 91     }
 92     /**
 93      *     设置二叉树的结构和值,构建时是传入的数组会以下标从小到大按根,左,右顺序构建,例如:
 94      *         {1,2,3,4,5,6,7,8,9}
 95      *             会被构建成
 96      *           1
 97      *         /   \
 98      *        2     3
 99      *       /\     /\
100      *      4  5   6  7
101      *     / \
102      *    8   9
103      * @param array
104      */
105     public void setArray(int[] array) {
106         this.array = array;
107     }
108 }

前中后序遍历测试代码:

@org.junit.Test
    public void BinTreeTest() {
        Tree tree=new Tree();
        tree.createTree();
        System.out.println("前序遍历");
        Tree.preOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("中序遍历");
        Tree.inOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("后序遍历");
        Tree.postOrdertraverse(tree.getNodelist());
    }

测试结果:

 

posted on 2019-10-16 10:13  Not_Leave_Regrets  阅读(...)  评论(...编辑  收藏

导航

统计