二叉樹的查找和刪除-JAVA語言實現

public class BinaryTree {
    TreeNode root;

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    public TreeNode getRoot() {
        return root;
    }

    //前序遍歷
    public void preOrder(){
        if (root != null){
            root.preOrder();
        }
    }
    //中序遍歷
    public void midOrder(){
        if (root != null){
            root.midOrder();
        }
    }
    //後序遍歷
    public void postOrder(){
        if (root != null){
            root.postOrder();
        }
    }

    public TreeNode preOrderSearch(int i){
        return root.preOrderSearch(i);
    }

    public void delete(int i) {
        if (root.value == i){
            root = null;
        } else{
            root.delete(i);
        }
    }
}

public class TestBinaryTree {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        //創建第一層根節點
        TreeNode root = new TreeNode(1);
        binaryTree.setRoot(root);

        //創建第二層節點
        TreeNode leftNode2 = new TreeNode(2);
        root.setLeftNode(leftNode2);
        TreeNode rightNode2 = new TreeNode(3);
        root.setRightNode(rightNode2);

        //創建第3層節點
        leftNode2.setLeftNode(new TreeNode(4));
        leftNode2.setRightNode(new TreeNode(5));

        rightNode2.setLeftNode(new TreeNode(6));
        rightNode2.setRightNode(new TreeNode(7));


        System.out.println("二叉樹的查找:");
        TreeNode searchResult = binaryTree.preOrderSearch(5);
        System.out.println(searchResult);

        System.out.println("二叉樹的刪除:");
        binaryTree.delete(1);
        binaryTree.postOrder();

    }
}

public class TreeNode {
    int value;
    TreeNode leftNode;
    TreeNode rightNode;

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


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


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

    //前序遍歷
    public void preOrder(){
        System.out.println(value);
        if (leftNode != null){
            leftNode.preOrder();
        }
        if (rightNode != null){
            rightNode.preOrder();;
        }
    }
    //中序遍歷
    public void midOrder(){
        if (leftNode != null){
            leftNode.midOrder();
        }
        System.out.println(value);
        if (rightNode != null){
            rightNode.midOrder();;
        }
    }
    //後序遍歷
    public void postOrder(){
        if (leftNode != null){
            leftNode.postOrder();
        }
        if (rightNode != null){
            rightNode.postOrder();;
        }
        System.out.println(value);
    }

    //前序查找
    public TreeNode preOrderSearch(int i){
        TreeNode targetNode = null;
        if (this.value == i){
            return this;
        } else {
            if (leftNode != null){
                targetNode = leftNode.preOrderSearch(i);
            }
            if (targetNode != null){
                return targetNode;
            }
            if (rightNode != null){
                targetNode = rightNode.preOrderSearch(i);
            }
            return targetNode;
        }
    }

    public void delete(int i) {
        TreeNode parent = this;
        if (parent.leftNode != null && parent.leftNode.value == i){
            parent.leftNode = null;
            return;
        }
        if (parent.rightNode != null && parent.rightNode.value == i){
            parent.rightNode = null;
            return;
        }
        //遞歸檢查並且刪除左孩子
        parent = leftNode;
        if (parent != null){
            parent.delete(i);
        }
        //遞歸檢查並且刪除右孩子
        parent = rightNode;
        if (parent != null){
            parent.delete(i);
        }
    }
}