數據結構學習--Java刪除二叉樹節點

想了半天，是真的不好想（手動捂臉）

三種情況需要考慮：

1、該節點是葉子節點，沒有子節點

要刪除葉節點，只需要改變該節點的父節點的引用值，將指向該節點的引用設置為null就可以了。

 

 

2、該節點有一個子節點

改變父節點的引用，將其直接指向要刪除節點的子節點。

 

 

3、該節點有兩個子節點

要刪除有兩個子節點的節點，就需要使用它的中序后繼來替代該節點。

 

 代碼

package com.example.deer;

public class Tree {
    //根節點
    public Node root;

    /**
     * 插入節點
     * @param value
     */
    public void insert(long value,String sValue){
        //封裝節點
        Node newNode = new Node(value,sValue);
        //引用當前節點
        Node current = root;
        //引用父節點
        Node parent;
        //如果root為null，也就是第一次插入的時候
        if(root == null){
            root = newNode;
            return;
        }else{
            while (true){
                //父節點指向當前節點
                parent = current;
                //如果當前指向的節點數據比插入的要大，則向左走
                if(current.data > value){
                    current = current.leftChild;
                    if(current == null){
                        parent.leftChild = newNode;
                        return;
                    }
                }else{
                    current = current.rightChild;
                    if(current == null){
                        parent.rightChild = newNode;
                        return;
                    }
                }
            }
        }
    }
    /**
     * 查找節點
     */
    public Node find(long value){
        //引用當前節點，從根節點開始
        Node current = root;
        //循環，只要查找值不等於當前節點的數據項
        while(current.data != value){
            //進行比較，比較查找值和當前節點的大小
            if(current.data > value){
                current = current.leftChild;
            } else {
              current = current.rightChild;
            }
            if(current == null){
                return null;
            }
        }
        return current;
    }

    /**
     * 刪除節點
     */
    public boolean delete(long value){
        //引用當前節點，從根節點開始
        Node current = root;
        //應用當前節點的父節點
        Node parent = root;
        //是否為左節點
        boolean isleftChild = true;

        while(current.data != value){
            parent = current;
            //進行比較，比較查找值和當前節點的大小
            if(current.data > value){
                current = current.leftChild;
                isleftChild = true;
            } else {
                current = current.rightChild;
                isleftChild = false;
            }
            if(current == null){
                return false;
            }
        }
        //刪除葉子節點，也就是該節點沒有子節點
        if(current.leftChild == null && current.rightChild == null){
            if(current == root){
                root = null;
            }else if(isleftChild){//如果它是父節點的左子節點
                parent.leftChild = null;
            }else{
                parent.rightChild = null;
            }
        }else if (current.rightChild == null){
            if(current == root){
                root = current.leftChild;
            }else if(isleftChild){
                parent.leftChild = current.leftChild;
            }else{
                parent.rightChild = current.leftChild;
            }
        }else if (current.leftChild == null){
            if(current == root){
                root = current.rightChild;
            }else if(isleftChild){
                parent.leftChild = current.rightChild;
            }else{
                parent.rightChild = current.rightChild;
            }
        } else {
            Node successor = getSuccessor(current);
            if(current == root){
                root = successor;
            } else if(isleftChild) {
                parent.leftChild = successor;
            }else{
                parent.rightChild = successor;
            }
            successor.leftChild = current.leftChild;
        }
        return true;
    }

    /**
     * 尋找中繼節點
     * @param delNode
     * @return
     */
    public Node getSuccessor(Node delNode){
        Node successor = delNode;
        Node successorParent = delNode;
        Node current = delNode.rightChild;
        while(current != null){
            successorParent = successor;
            successor = current;
            current = current.leftChild;
        }
        if(successor != delNode.rightChild){
            //
            successorParent.leftChild = successor.rightChild;
            //將刪除的節點的整個右子樹掛載到中繼節點的右子樹上
            successor.rightChild = delNode.rightChild;
        }
        return successor;
    }
    /**
     * 前序遍歷
     */
    public void frontOrder(Node localNode){
        if(localNode != null){
            //訪問根節點
            System.out.println(localNode.data + "," + localNode.sData);
            //前序遍歷左子樹
            frontOrder(localNode.leftChild);
            //前序遍歷右子樹
            frontOrder(localNode.rightChild);
        }
    }

    /**
     * 中序遍歷
     */
    public void inOrder(Node localNode){
        if(localNode != null){
            //中序遍歷左子樹
            inOrder(localNode.leftChild);
            //訪問根節點
            System.out.println(localNode.data + "," + localNode.sData);
            //中序遍歷右子樹
            inOrder(localNode.rightChild);
        }
    }
    /**
     * 后序遍歷
     */
    public void afterOrder(Node localNode){
        if(localNode != null){
            //后序遍歷左子樹
            afterOrder(localNode.leftChild);
            //后序遍歷右子樹
            afterOrder(localNode.rightChild);
            //訪問根節點
            System.out.println(localNode.data + "," + localNode.sData);
        }
    }
}