जावा द्विआधारी खोज वृक्ष

इस होमवर्क है? कुछ भी नहीं है कि के साथ गलत ... हम सिर्फ लोगों को सीखने में मदद करने के बजाय उन्हें जवाब बताना चाहते।

शून्य पर तुम सिर्फ चाइल्ड नोड सेट करते हैं आप बच्चे बच्चों के बारे में किसी भी जानकारी को खो देंगे।

एक मानक पेड़ वर्ग अपने बच्चों, आम तौर पर किसी सरणी या संग्रह में फंस पता चल जाएगा - एक द्विआधारी पेड़ के मामले में, आप केवल दो प्रत्यक्ष बच्चों, इसलिए एक निश्चित आकार सरणी काम करेंगे मिल गया है। इस कारण से, वे आम तौर पर उस बच्चे बच्चों की उस सूची से हटा पाने के लिए कॉल "removeMe" विधि के कुछ प्रकार लागू।

जैसा कि ऊपर उल्लेख, इस जटिल हो जाता है अगर बच्चे को आप निकाल रहे बच्चे हैं।

टिम जवाब सबसे अच्छा लगता है। लेकिन हाँ आप तीन बातों में से एक बच्चे को किस तरह यह अपने को दूर करने के आधार पर करना चाहते हैं जाएगा। आप एक बच्चे अशक्त करते हैं, इसके बारे में बच्चों को स्थानांतरित नहीं होगा क्योंकि आप उन के संदर्भ खो दिया है। इसके बजाय, आप निर्धारित करने के लिए बच्चे को अपने को दूर करने के बाईं या दाईं बच्चों बच्चे अपने को दूर करने के लिए सूचक की ओर इशारा करते सेट किया जाना चाहिए अगर चाहता हूँ। आप सेट करने के बाद पिछले 'नोड बच्चे को सूचक (बाएं या दाएं) (बाएं या दाएं) नोड अपने को दूर करने के, आप अभ्यस्त एक संदर्भ अब और है कि नोड के लिए है, तो थेरेस कोई यह शून्य पर सेट करने के लिए (आप कर सकते हैं की जरूरत है' टी अब यह उपयोग। जब तक आप दोगुना से जुड़े BST किसी प्रकार का, जिस स्थिति में क्लासिक BST नहीं है कि लिखा था)

इस कोड को आप की मदद करनी चाहिए

public Node<T> getParentOf(Node<T> child){
    findParentOf(this.root, child);
    return temp;
}

private void findParentOf(Node<T> ROOT, Node<T> child){
    if(ROOT.hasLeft()){
        findParentOf(ROOT.left, child);
    }

    if(ROOT.left == child || root.right == child){
        temp = ROOT;
    }

    if(ROOT.hasRight()){
        findParentOf(ROOT.right, child);
    }
}


private void replaceNode(Node<T> original, Node<T> newNode){
    Node<T> tempParent = getParentOf(original);
    if(original == tempParent.left){
        tempParent.left = newNode;
    }else if(original == tempParent.right){
        tempParent.right = newNode;
    }
}

private void traverseChildrenAndAdd(Node<T> newParent, Node<T> oldParent){
    newParent.insert(oldParent.data);
    if(oldParent.hasLeft()){
        traverseChildrenAndAdd(newParent,oldParent.left);
    }



    if(oldParent.hasRight()){
        traverseChildrenAndAdd(newParent,oldParent.right);
    }
}
private void deleteNode(Node<T> ROOT, Node<T> d){
    if(d.data.compareTo(ROOT.data) < 0){
        deleteNode(ROOT.left, d);
    }else if(d.data.compareTo(ROOT.data) > 0){
        deleteNode(ROOT.right, d);
    }else if(d == this.root){
        if(this.root.hasLeft()){
            traverseChildrenAndAdd(root.left, root.right);
            root = root.left;
        }else if(root.hasRight()){
            root = root.right;
        }else{
            root = null;
        }
    }else{
        if(ROOT.hasLeft()&&ROOT.hasRight()){
            Node<T> successor = getMinNode(ROOT);
            replaceNode(successor, successor.right);
        }else if(ROOT.hasLeft() || ROOT.hasRight()){
            if(ROOT.hasLeft()){
                replaceNode(ROOT, ROOT.left);
            }else{
                replaceNode(ROOT, ROOT.right);
            }
        }else{
            replaceNode(ROOT, null);
        }
    }
}

public void remove(T data){
    deleteNode(this.root, new Node<T>(data));
}

आप इस (छद्म कोड) की तरह कुछ कर सकते हैं:

यह देखते हुए एक पेड़ "रूट" और नोड की जड़ को नष्ट करने या कुछ डेटा "x" निम्न कार्य करें

 if x < root
      recurse to left child
 if x > root
      recurse to right child
 else //node found
      find the min item of the node right child //min item should be left most leaf node node
      replace the value of the node you want to delete with min nodes value
      now delete the min node
 return root;

कोड:

delete(Node root, Object x){
    if(root == null){
        return null;
    }

    if(data < root.data){
        root = delete(root.left);
    }else if(root.data < data){
        root = delete(root.right);
    }else{
        if(root.left != null && root.right != null){
            Object tmp = findMin(root.right);
            root.data = tmp;
            root.right = delete(root.right, tmp);
        }else{
            return (root.left != null) ? root.left : root.right;    
        }
    }
return root;

}