【データ構造とアルゴリズム】十五二叉木遍歴Depth-First-Search深さ優先

【データ構造とアルゴリズム】十五二叉木遍歴Depth-First-Search深さ優先
前の二叉木の文章を結びつける.ツリーのすべてのノードにアクセスし、1回のみアクセスします.Depth-First-Search深さ優先深さ優先深さ優先アルゴリズムは3種類あります
前順ループ:ルートノード->左サブツリー->右サブツリー

 private void preorder(Node node){ if(null == node) return ; System.out.print(node.value); preorder(node.left); preorder(node.right); }

中順遍歴:左サブツリー->ルートノード->右サブツリー

    private void midorder(Node node){
        if(null == node)
            return ; 
        midorder(node.left);
        System.out.print(node.value);
        midorder(node.right);
    }

後方ループ:左サブツリー->右サブツリー->ルートノード

    private void postorder(Node node){
        if(null == node)
            return ; 
        postorder(node.left);
        postorder(node.right);
        System.out.print(node.value);
    }

完全コード

package com.cn.mark.algorithm.binarytree;


public class BST <T extends Comparable<? super T>>{


    private static class Node<T> {

        private T value ; 
        private Integer position ; 
        private Integer height ;
        private Node<T> left;
        private Node<T> right;


        public Node(T value , Integer position, Node<T> left, Node<T> right) {
            this.value =  value;
            this.position = position ; 
            this.height = 0;
            this.left = left;
            this.right = right;
        }
    }

    private int height(Node<T> t) {
        return t == null ? -1 : t.height;
    }

    private Node<T> root ; 

    public void add(T value , Integer position){
        root = add( value , position, root );
    }

    private Node<T> add(T value , Integer position, Node<T> node){
        if(node == null){
            return new Node<T>(value,position , null ,null);
        }

        int comparaResult = value.compareTo(node.value);

        if(comparaResult > 0)
            node.right = add(value , position , node.right);
        else if (comparaResult < 0)
            node.left = add(value , position , node.left);
        else 
            System.out.println("as same a value");

        node.height = Math.max(height(node.left), height(node.right)) + 1;
        return node;

    }

    public Integer search(Node<T> node , T value){
        if(node == null)
            return -1 ; 
        int comparaResult = value.compareTo(node.value);
        if(comparaResult == 0)
            return node.position;
        else if(comparaResult > 0)
            return search(node.right, value);
        else if(comparaResult < 0)
            return search(node.left, value);
        else
            return -1;
    }



    private void preorder(Node<T> node){
        if(null == node)
            return ; 
        System.out.print(node.value);
        preorder(node.left);
        preorder(node.right);
    }


    private void midorder(Node<T> node){
        if(null == node)
            return ; 
        midorder(node.left);
        System.out.print(node.value);
        midorder(node.right);
    }


    private void postorder(Node<T> node){
        if(null == node)
            return ; 
        postorder(node.left);
        postorder(node.right);
        System.out.print(node.value);
    }


    public static void main(String[] args){
        BST<Integer> bst = new BST<Integer>();
          int[] array = {0,1,5,6,7,2,3,4,8,9};
        for(int i=0;i<array.length;i++)
            bst.add(array[i],i);// 
        System.out.println(bst.height(bst.root));
        System.out.println(bst.search(bst.root, 8));
        System.out.println(bst.search(bst.root, 0));
        System.out.println(bst.search(bst.root, 22));

        bst.preorder(bst.root);
        System.out.println();
        bst.midorder(bst.root);
        System.out.println();
        bst.postorder(bst.root);
    }
}