二叉树的基本定义

包括二叉树的前序遍历，中序遍历和后序遍历。

下面的代码是一个基本的二叉树，非二叉排序树和平衡二叉树

声明：下面的代码只是一个最基础的实现，没有经过严格的测试。

 

/**
 * 二叉树
 * 树的遍历参考：https://www.cnblogs.com/zhi-leaf/p/10813048.html
 */
public class BinaryTree {
    public static void main(String[] args) {
        BinaryTree tree =new BinaryTree();
        Node root = tree.createNode(1, "宋江");
        Node node2 = tree.createNode(2, "吴用");
        Node node3 = tree.createNode(3, "卢俊义");
        Node node4 = tree.createNode(4, "林冲");
        Node node5 = tree.createNode(5, "关胜");

        root.left=node2;
        root.right=node3;
        node3.right=node4;
        node3.left=node5;
        tree.rootNode=root;

        tree.preOrderByStack(root);

/*        Node node = tree.preOrderSearch(root, 5);
        System.out.println(node);*/
/*        tree.preOrder(root);
        tree.preOrderDelSimple(tree.rootNode,1);
        System.out.println("----------------");
        tree.preOrder(tree.rootNode);*/


    }
    public Node rootNode;

    public Node createNode(Integer id, String name){
        return new Node(id,name);
    }

    //前序遍历，先父节点再左节点，后右节点
    public void preOrder(Node node){
        if(node==null){
            return;
        }
        //每次都是先输出父节点
        System.out.println(node);
        if(node.left!=null){
            preOrder(node.left);
        }
        if(node.right!=null){
            preOrder(node.right);
        }
    }

    /**
     * 前序遍历，非递归方式(利用了栈的回溯功能)
     * 思路：输出父节点之后，将父节点push到栈中，然后循环获取每个父节点的左子节点。直到左子节点为null。
     * 此时stack最上层的节点就是左子节点为空的节点，pop出该节点，尝试获取右子节点并输出，如果右子节点为空，则继续pop直到
     * 获取到右子节点不为空的节点,输出该节点并获取左子节点并push，直到node为空或者栈为空为止
     * @param node
     */
    public  void preOrderByStack(Node node){
       // MyArrayStack
        MyLinkedStack<Node> stack = new MyLinkedStack<>();

        while (node != null || !stack.isEmpty()){
            if(node != null){
                System.out.println(node);
                stack.push(node);
                node=node.left;
            }else{
                Node temp = stack.pop();
                node=temp.right;
            }
        }
    }

    //中序遍历，先左节点再父节点，后右节点
    public void infixOrder(Node node){
        if(node==null){
            return;
        }

        //每次都是先输出父节点
        if(node.left!=null){
            infixOrder(node.left);
        }
        System.out.println(node);
        if(node.right!=null){
            infixOrder(node.right);
        }
    }


    //后序遍历，先左节点再右节点，后父节点
    public void postOrder(Node node){
        if(node==null){
            return;
        }
        //每次都是先输出父节点
        if(node.left!=null){
            postOrder(node.left);
        }

        if(node.right!=null){
            postOrder(node.right);
        }

        System.out.println(node);
    }

    //前序查找，先父节点再左节点，后右节点。中序和后序查找，类似
    public Node preOrderSearch(Node node,Integer id){
        //如果当前节点是，直接返回
        if(id==node.getId()){
            return node;
        }

        //如果左递归中查找到，则返回
        if(node.left!=null){
            Node nd= preOrderSearch(node.left,id);
            if(nd!=null){
                return nd;
            }
        }
        //如果右递归中查找到，则返回
        if(node.right!=null){
            Node nd= preOrderSearch(node.right,id);
            if(nd!=null){
                return nd;
            }
        }

        return null;
    }

    /**
     * 节点删除的简单实现
     * 如果待删除的节点是头节点，则直接将头节点置空.
     * 如果是叶子节点，则删除该节点
     * 如果是非叶子，则删除该子树
     * @param node
     * @param id
     */
    public   void preOrderDelSimple(Node node, Integer id){
        if(id==this.rootNode.getId()){
            this.rootNode=null;
            return;
        }else{
            preOrderDeleteSimple(node,id);
        }
    }

    /**
     *
     * @param node
     * @param id
     */
    private  void preOrderDeleteSimple(Node node, Integer id) {
        if (node.left != null && node.left.getId() == id) {
            node.left = null;
            return;
        }

        if (node.right != null && node.right.getId() == id) {
            node.right = null;
            return;
        }
        if (node.left != null) {
            preOrderDeleteSimple(node.left, id);
        }
        if (node.right != null) {
            preOrderDeleteSimple(node.right, id);
        }


    }
}
class Node{
    //id
    private Integer id;
    //姓名
    private String name;
    //左节点
    public Node left;
    //右节点
    public Node right;

    public Node(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}