树的遍历（java版）

  class TreeNode{
    int value;
    TreeNode leftNode;
    TreeNode rightNode;
    public TreeNode(int value)
    {
        this.value=value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    public void frontShow()
    {
        System.out.println(value);
        if(leftNode!=null)
        {
            leftNode.frontShow();
        }
        if(rightNode!=null)
        {
            rightNode.frontShow();
        }
    }
    public void middleShow()
    {
        if(leftNode!=null)
        {
            leftNode.middleShow();
        }
        System.out.println(value);
        if(rightNode!=null)
        {
            rightNode.middleShow();
        }
    }
    public void rightShow()
    {
        if(leftNode!=null)
        {
            leftNode.rightShow();
        }
        if(rightNode!=null)
        {
            rightNode.rightShow();
        }
        System.out.println(value);
    }
    //前序查找
    public TreeNode frontSearch( int target)
    {
        TreeNode targetNode=null;
        if(this.value==target)
        {
            return this;
        }
        else
        {
            if(leftNode!=null)
            {
                targetNode=leftNode.frontSearch(target);
            }
            if(targetNode!=null)
            {
                return targetNode;
            }
            if(rightNode!=null)
            {
                targetNode=rightNode.frontSearch(target);
            }
        }
        return targetNode;
    }
    //前序遍历删除
    public void delete(int target)
    {
        TreeNode parent=this;
        if(parent.leftNode.value==target)
        {
            parent.leftNode=null;
            return;
        }
        if(parent.rightNode.value==target)
        {
            parent.rightNode=null;
            return;
        }
        if(leftNode!=null)
        {
            parent=leftNode;
            parent.delete(target);
        }
        if(rightNode!=null)
        {
            parent=rightNode;
            parent.delete(target);
        }
    }

    public void dfs(TreeNode head)
    {
        if(head==null) return;
        Stack stack=new Stack<>();
        stack.push(head);
        while (!stack.isEmpty())
        {
            TreeNode treeNode=stack.pop();
            System.out.println(treeNode.value);
            System.out.println(" ");
            if(treeNode.rightNode!=null)
            {
                stack.push(treeNode.rightNode);
            }
            if(treeNode.leftNode!=null)
            {
                stack.push(treeNode.leftNode);
            }
        }
    }
    public void bfs(TreeNode head)
    {
        if(head==null)
        {
            return;
        }
        Queue queue=new linkedList<>();
        queue.add(head);
        while (!queue.isEmpty())
        {
            TreeNode treeNode=queue.poll();
            System.out.println(treeNode.value);
            System.out.println(" ");
            if(treeNode.leftNode!=null)
            {
                queue.add(treeNode.leftNode);
            }
            if(treeNode.rightNode!=null)
            {
                queue.add(treeNode.rightNode);
            }
        }
    }
}