एक द्विआधारी खोज पेड़ से एक नोड हटाया जा रहा है

Question

एक द्विआधारी खोज पेड़ से एक नोड हटाया जा रहा है

वोट

0

मेरे बाइनरी खोजें ट्री कार्यक्रम कुछ भी हटाए जा करने के लिए जब मैं deleteNode विधि कॉल नहीं लगती। BST पूरी तरह से बनाया गया है, इसकी सिर्फ नोड बात यह है कि काम नहीं करता है हटा रहा है। मैं इसे इस तरह अपने मुख्य से कहते हैं:

System.out.println(Please enter a number you would like to delete from the tree);
    temp = reader.nextLine();
    try {
        int numTemp = Integer.parseInt(temp);
        TreeNode treeTemp = bst.deleteNode(numTemp, bst.getRoot());
        bst.setRoot(treeTemp);
    }
    catch(Throwable e){
        System.err.println(e);
    }
    bst.printInBST(bst.getRoot());

मेरी BinarySearchTree कक्षा में मैं निम्नलिखित के रूप में मेरे deleteNode तरीकों को लागू:

public TreeNode deleteNode(int x, TreeNode temp){
    if(temp != null){
        if(x > (int)((Integer)temp.getValue())){
            temp.setLeft(deleteNode(new Integer(x), temp.getLeft()));
        }
        else if(x < (int)((Integer)temp.getValue())){
            temp.setRight(deleteNode(new Integer(x), temp.getRight()));
        }
        else if(temp.getLeft() != null & temp.getRight() != null){
            TreeNode temp2 = new TreeNode(temp.getRight().getValue());
            while(temp2.getLeft() != null){
                temp2 = temp2.getLeft();
            }
            temp = temp2;
            temp.setRight(remove(temp.getRight()));
        }
    }
    return temp;
}
public TreeNode remove(TreeNode temp){
        if(temp.getLeft() != null){
            temp.setLeft(remove(temp.getLeft()));
            return temp;
        }
        else {
            return temp.getRight();
        }
}

java binary-search-tree

08/10/2011 को 18:52
का स्रोत उपयोगकर्ता user985626

अन्य भाषाओं में...

4 जवाब

Gary · Answer 1 · 2011-10-08 19:25

यदि यह आपका ही समस्या है, लेकिन चाहिए नहीं 100% यकीन है कि:

else if(temp.getLeft() != null & temp.getRight() != null)

वास्तव में हो सकता है:

else if(temp.getLeft() != null && temp.getRight() != null)

यानी आप केवल एक और 'और' आपरेशन आप दो होनी चाहिए जब के लिए है?

Sashwat · Answer 2 · 2011-10-08 20:39

मुझे लगता है कि आप से निपटने नहीं कर रहे हैं

मामले 1: जहां हटाने नोड एक पत्ता नोड है

मामले 2: जहां हटाने नोड सिर्फ 1 बच्चा है

बाकी अगर हिस्सा कुछ इस तरह होना चाहिए।

else if( temp.getLeft() != null && temp.getRight() != null ) // Two children
{
      temp.setValue( findMin( temp.getRight() ).getValue());
      temp.setRight ( deleteNode( temp.getValue(), temp.getRight() );
}
else
     temp = ( temp.getLeft() != null ) ? temp.getLeft() : temp.getRight();

return temp;

findMin विधि नोड के लिए inorder उत्तराधिकारी हटाए जाने के लिए मिल रहा है।

private TreeNode findMin( TreeNode t )
{
        if( t == null )
            return null;
        else if( t.getLeft() == null )
            return t;
        return findMin( t.getLeft() );
}

मैं आपके प्रश्न का उत्तर उम्मीद है।

meriton · Answer 3 · 2011-10-09 00:01

खुद को और दूसरों के द्वारा दोनों - सुपाठ्य कोड लिखने कीड़े आसान स्थान है। एक पहला कदम की तुलना में अधिक अर्थपूर्ण चर नाम का चयन किया जाता है temp, temp2और treeTemp।

इसके अलावा, यह करने के लिए वास्तव में आवश्यक नहीं है new Integer(x)प्रकार की एक विधि पैरामीटर आवंटित करने के लिए int। सीधे शब्दों में लिख xबजाय एक ही प्रभाव है, क्रम में तेजी से होता है, और यह आसान कोड है कि मायने रखती स्थान है।

कीड़े के रूप में, पहले एक मैं देख रहा हूँ है:

TreeNode temp2 = new TreeNode(temp.getRight().getValue());

यही कारण है कि TreeNode एक कॉपी बन जाती। कि प्रति बदलते हैं तो मूल नोड को प्रभावित नहीं करेगा। इसके अलावा, प्रति शायद नहीं है leftया rightनिर्धारित करते हैं, जब से तुम ही पारित valueनिर्माता है। मुझे आश्चर्य है कि क्यों आप एक प्रति की जरूरत लगता है? सब के बाद, आप एक यहाँ या तो नहीं:

deleteNode(new Integer(x), temp.getRight())

इसके बाद, के रूप में Sashwat बताते हैं, नष्ट करने के लिए नोड कम से कम 2 बच्चे हैं, तो आपके कोड कुछ भी में स्थिति से कोई भी ऐसा नहीं करता है, deleteNodeमैचों।

moath sara · Answer 4 · 2013-01-29 18:54

  public class BSTNode {
  …

  public boolean remove(int value, BSTNode parent) {
        if (value < this.value) {
              if (left != null)
                    return left.remove(value, this);
              else
                    return false;
        } else if (value > this.value) {
              if (right != null)
                    return right.remove(value, this);
              else
                    return false;
        } else {
              if (left != null && right != null) {
                    this.value = right.minValue();
                    right.remove(this.value, this);
              } else if (parent.left == this) {
                    parent.left = (left != null) ? left : right;
              } else if (parent.right == this) {
                    parent.right = (left != null) ? left : right;
              }
              return true;
        }
  }