手写实现二叉树

手写实现二叉树

最近被各种树各种摧残，还好如今挺过来了。今天试着自己写一个二叉树。
参考来源： https://zhuanlan.zhihu.com/p/90309039

树的节点属性类

一个二叉树，要知道左侧节点，和右侧节点，和值，这样能知道，二叉树的所有节点，左侧节点小于右侧节点的特性。

public class Node {

    /**
     * 值
     */
    int value;
    /**
     * 右子树节点
     */
    Node rightNode;
    /**
     * 左子树节点
     */
    Node leftNode;

    public Node(int value, Node rightNode, Node leftNode) {
        this.value = value;
        this.rightNode = rightNode;
        this.leftNode = leftNode;
    }

    public int getValue() {
        return value;
    }

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

    public Node getRightNode() {
        return rightNode;
    }

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

    public Node getLeftNode() {
        return leftNode;
    }

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

二叉树新增

public class BinaryTree {

    private static Node rootNode;

    /**
     * 新增节点
     * @param currentNode
     * @param value
     * @return
     */
    public static Node addNode(Node currentNode, int value){
        if(currentNode == null){
            return new Node(value,null,null);
        }
        if(currentNode.getValue() < value){
            currentNode.rightNode = addNode(currentNode.getRightNode(),value);
        }
        if(currentNode.getValue() > value){
            currentNode.leftNode = addNode(currentNode.getLeftNode(),value);
        }
        return currentNode;
    }

    public static void main(String[] args) {
        rootNode = addNode(rootNode,8);
        rootNode = addNode(rootNode,18);
        rootNode = addNode(rootNode,3);
        rootNode = addNode(rootNode,5);
        rootNode = addNode(rootNode,3);
        rootNode = addNode(rootNode,6);
        rootNode = addNode(rootNode,9);
        rootNode = addNode(rootNode,2);
    }

删除节点

删除是二叉树比较特殊的操作，删除后还是要满足从左到右，依此值变大。
有三种情况：
1.被删除的节点，没有子节点，此时直接删除即可
2.被删除的节点，有一个节点，此时将存在的节点返回
3.被删除的节点，存在两个子节点，由于二叉树的排序特性，右侧节点，比左侧节点值大，所以将右侧最左的节点，替换到将要删除的节点，次是可以保证从左到右依此值变大。

package com.searchtree.BinaryTree;

import java.util.LinkedList;

public class BinaryTree {

    private static Node rootNode;

    /**
     * 删除节点
     * @param currentNode
     * @param value
     */
    public static Node deleteNode(Node currentNode, int value){
        if(currentNode == null){
            return currentNode;
        }
        if(currentNode.getValue() == value){
            //被删除节点的左右子节点都为空
            if(currentNode.rightNode == null && currentNode.leftNode == null){
                return null;
            }
            //被删除节点有一个子节点
            if(currentNode.rightNode == null){
                return currentNode.leftNode;
            }
            if(currentNode.leftNode == null){
                return currentNode.rightNode;
            }
            //被删除节点有两个子节点。

            //获取节点最小值
            int minValue = getLeftNodeValue(currentNode.rightNode);
            //将最小值替换到删除的节点
            currentNode.setValue(minValue);
            //删除替换的节点
            currentNode.rightNode = deleteNode(currentNode.rightNode,minValue);
        }
        if(currentNode.getValue() > value){
            currentNode.leftNode = deleteNode(currentNode.leftNode,value);
        }
        if(currentNode.getValue() < value){
            currentNode.rightNode = deleteNode(currentNode.rightNode,value);
        }
        return currentNode;
    }

    /**
     * 获取节点最小值
     * @param currentNode
     * @return
     */
    public static int getLeftNodeValue(Node currentNode){
        if(currentNode.leftNode != null){
            return getLeftNodeValue(currentNode.leftNode);
        }
        return currentNode.getValue();
    }

    public static void main(String[] args) {
        rootNode = deleteNode(rootNode,8);
    }
}

查询二叉树中是否有特定值

public class BinaryTree {

    private static Node rootNode;

    /**
     * 查询树中是否有特定值
     * @param currentNode
     * @param value
     * @return
     */
    public static boolean containsNodeRecursive(Node currentNode,int value){
        boolean flag = false;
        if(currentNode == null){
            return false;
        }
        if(currentNode.getValue() > value){
            flag =containsNodeRecursive(currentNode.leftNode,value);
        }
        if(currentNode.getValue() < value){
            flag = containsNodeRecursive(currentNode.rightNode,value);
        }
        if(currentNode.getValue() == value){
            return true;
        }
        return flag;
    }

    public static void main(String[] args) {
       
        System.out.println(containsNodeRecursive(rootNode,1));
        System.out.println(containsNodeRecursive(rootNode,10));
        System.out.println(containsNodeRecursive(rootNode,18));
        System.out.println(containsNodeRecursive(rootNode,2));
    }

从最左侧节点开始遍历树

public class BinaryTree {

    private static Node rootNode;

    /**
     * 遍历  从最左侧节点开始
     * @param currentNode
     */
    public static void traverseInOrder(Node currentNode){
        if(currentNode != null){
            traverseInOrder(currentNode.leftNode);
            System.out.print(currentNode.getValue()+ "--");
            traverseInOrder(currentNode.rightNode);
        }
    }

    public static void main(String[] args) {
        System.out.print("从最左侧节点开始遍历：");
        traverseInOrder(rootNode);
    }
}

首先访问根节点，然后是左子树，最后是右子树

public class BinaryTree {

    private static Node rootNode;

  
    /**
     * 首先访问根节点，然后是左子树，最后是右子树
     * @param currentNode
     */
    public static void traversePreOrder(Node currentNode){
        if(currentNode != null){
            System.out.print(currentNode.getValue()+ "--");
            traversePreOrder(currentNode.leftNode);
            traversePreOrder(currentNode.rightNode);
        }
    }

    
    public static void main(String[] args) {
        System.out.print("首先访问根节点，然后是左子树，最后是右子树：");
        traversePreOrder(rootNode);
    }
}

访问左子树，右子树，最后访问根节点

public class BinaryTree {

    private static Node rootNode;

    /**
     * 访问左子树，右子树，最后访问根节点
     * @param currentNode
     */
    public static void traversePostOrder(Node currentNode){
        if(currentNode != null){
            traversePostOrder(currentNode.leftNode);
            traversePostOrder(currentNode.rightNode);
            System.out.print(currentNode.getValue()+ "--");
        }
    }

    public static void main(String[] args) {
        System.out.print("访问左子树，右子树，最后访问根节点：");
        traversePostOrder(rootNode);
    }
}

按层级遍历

public class BinaryTree {

    private static Node rootNode;

    /**
     * 按层级遍历
     * @param currentNode
     */
    public static void traverseLevelOrder(Node currentNode){
        if(currentNode == null){
            return ;
        }
        LinkedList<Node> nodes = new LinkedList();
        nodes.add(currentNode);
        while (!nodes.isEmpty()){
            Node node = nodes.remove();
            System.out.print(node.getValue()+ "--");
            if(node.leftNode != null){
                nodes.add(node.leftNode);
            }
            if(node.rightNode != null){
                nodes.add(node.rightNode);
            }
        }
    }

    public static void main(String[] args) {
        System.out.print("按层级遍历：");
        traverseLevelOrder(rootNode);
    }
}