Πώς να βρείτε το πλησιέστερο στοιχείο σε μια δεδομένη βασική αξία σε ένα δυαδικό δέντρο αναζήτησης;

Η πιο εύκολη λύση είναι να recurse δέντρο σας από πότε

• μπορείτε να βρείτε το στοιχείο
• φτάσετε σε ένα φύλλο. Η υπόθεση αυτή θα πρέπει να κάνει ένα ζευγάρι σύγκρισης για να καθορίσει εάν η πλησιέστερη τιμή είναι το φύλλο ή ο γονέας του φύλλου.

Μέχρι που η εφαρμογή.

Traverse παίρνει O (n) χρόνο. Μπορούμε να προχωρήσουμε σε πάνω-κάτω; όπως αυτό αναδρομικές Κωδικός:

Tnode * closestBST(Tnode * root, int val){
    if(root->val == val)
        return root;
    if(val < root->val){
        if(!root->left)
            return root;
        Tnode * p = closestBST(root->left, val);
        return abs(p->val-val) > abs(root->val-val) ? root : p;
    }else{
        if(!root->right)
            return root;
        Tnode * p = closestBST(root->right, val);
        return abs(p->val-val) > abs(root->val-val) ? root : p;
    }   
    return null;
}

Μπορεί να λυθεί σε O (log * n *) χρόνο.

• Εάν η αξία ενός κόμβου είναι ίδια με την δεδομένη τιμή, αυτό είναι το πιο κοντινό κόμβο?
• Εάν η αξία ενός κόμβου είναι μεγαλύτερη από την καθορισμένη τιμή, μετακινηθείτε προς τα αριστερά παιδί?
• Εάν η αξία ενός κόμβου είναι μικρότερη από την καθορισμένη τιμή, μετακινηθείτε προς τα δεξιά παιδί.

Ο αλγόριθμος μπορεί να υλοποιηθεί με τον ακόλουθο κώδικα C ++:

BinaryTreeNode* getClosestNode(BinaryTreeNode* pRoot, int value)
{
    BinaryTreeNode* pClosest = NULL;
    int minDistance = 0x7FFFFFFF;
    BinaryTreeNode* pNode = pRoot;
    while(pNode != NULL){
        int distance = abs(pNode->m_nValue - value);
        if(distance < minDistance){
            minDistance = distance;
            pClosest = pNode;
        }

        if(distance == 0)
            break;

        if(pNode->m_nValue > value)
            pNode = pNode->m_pLeft;
        else if(pNode->m_nValue < value)
            pNode = pNode->m_pRight;
    }

    return pClosest;
}

Μπορείτε να επισκεφθείτε το blog μου για περισσότερες λεπτομέρειες.

Αυτό μπορεί να γίνει χρησιμοποιώντας μια ουρά και ένα ArrayList. Ουρά θα χρησιμοποιηθεί για να εκτελέσει μια εύρος πρώτη αναζήτηση στο δέντρο. ArrayList θα χρησιμοποιείται για την αποθήκευση του στοιχείου του δέντρου σε εύρος πρώτης τάξης. Εδώ είναι ο κώδικας για την εφαρμογή της ίδιας

Queue queue = new LinkedList();
ArrayList list = new ArrayList();
int i =0;
public Node findNextRightNode(Node root,int key)
{
    System.out.print("The breadth first search on Tree : \t");      
    if(root == null)
        return null;

    queue.clear();
    queue.add(root);

    while(!queue.isEmpty() )
    {
        Node node = (Node)queue.remove();
        System.out.print(node.data + " ");
        list.add(node);
        if(node.left != null) queue.add(node.left);
        if(node.right !=null) queue.add(node.right);            
    }

    Iterator iter = list.iterator();
    while(iter.hasNext())
        {
            if(((Node)iter.next()).data == key)
            {
                return ((Node)iter.next());
            }               
        }

    return null;
}

Το πρόβλημα με την προσέγγιση «αριστερά δεξιά διάσχισης και να βρεθεί η πλησιέστερη» είναι ότι εξαρτάται πάνω από τη σειρά με την οποία τα στοιχεία είχαν εγγραφεί για να δημιουργήσετε BST. Εάν ψάχνουμε 11 για την ακολουθία BST 22, 15, 16, 6,14,3,1,90, η παραπάνω μέθοδος θα επιστρέψει 15, ενώ η σωστή απάντηση είναι 14. Η μόνη μέθοδος θα πρέπει να χρησιμοποιούν αναδρομή για να διασχίσει όλους τους κόμβους, επιστρέφοντας το πιο κοντινό μία ως αποτέλεσμα την αναδρομική συνάρτηση. Αυτό θα μας δώσει την πλησιέστερη τιμή

Εδώ είναι μια αναδρομική λύση στην Python:

def searchForClosestNodeHelper(root, val, closestNode):
    if root is None:
        return closestNode

    if root.val == val:
        return root

    if closestNode is None or abs(root.val - val) < abs(closestNode.val - val):
        closestNode = root

    if val < root.val:
        return searchForClosestNodeHelper(root.left, val, closestNode)
    else:
        return searchForClosestNodeHelper(root.right, val, closestNode)

def searchForClosestNode(root, val):
    return searchForClosestNodeHelper(root, val, None)

void closestNode(Node root, int k , Node result) {
    if(root == null) 
    {
       return;      //currently result is null , so it  will be the result
    }
    if(result == null || Math.abs(root.data - k) < Math.abs(result.data - k) )
    {
      result == root;
    }
    if(k < root.data)
    {
    closestNode(root.left, k, result)
    } 
    else 
    {
        closestNode(root.right, k, result);
    }

}

Κάτω από ένα δουλεύει με διαφορετικά δείγματα που έχω.

public Node findNearest(Node root, int k) {
    if (root == null) {
        return null;
    }
    int minDiff = 0;
    Node minAt = root;
    minDiff = Math.abs(k - root.data);

    while (root != null) {
        if (k == root.data) {
            return root;
        }
        if (k < root.data) {
            minAt = updateMin(root, k, minDiff, minAt);
            root = root.left;
        } else if (k > root.data) {
            minAt = updateMin(root, k, minDiff, minAt);
            root = root.right;
        }

    }
    return minAt;
}

private Node updateMin(Node root, int k, int minDiff, Node minAt) {
    int curDif;
    curDif = Math.abs(k - root.data);
    if (curDif < minDiff) {
        minAt = root;
    }
    return minAt;
}

Εδώ είναι ο πλήρης κώδικας της Java για να βρείτε το πλησιέστερο στοιχείο σε ένα BST.

        package binarytree;

        class BSTNode {
            BSTNode left,right;
            int data;

            public BSTNode(int data) {
                this.data = data;
                this.left = this.right = null;
            }
        }

        class BST {
            BSTNode root;

            public static BST createBST() {
                BST bst = new BST();
                bst.root = new BSTNode(9);
                bst.root.left = new BSTNode(4);
                bst.root.right = new BSTNode(17);

                bst.root.left.left = new BSTNode(3);
                bst.root.left.right= new BSTNode(6);

                bst.root.left.right.left= new BSTNode(5);
                bst.root.left.right.right= new BSTNode(7);

                bst.root.right.right = new BSTNode(22);
                bst.root.right.right.left = new BSTNode(20);

                return bst;
            }
        }

        public class ClosestElementInBST {
            public static void main(String[] args) {
                BST bst = BST.createBST();
                int target = 18;
                BSTNode currentClosest = null;
                BSTNode closestNode = findClosestElement(bst.root, target, currentClosest);

                if(closestNode != null) {
                    System.out.println("Found closest node: " + closestNode.data);
                }
                else {
                    System.out.println("Couldn't find closest node.");
                }
            }

            private static BSTNode findClosestElement(BSTNode node, int target, BSTNode currentClosest) {
                if(node == null) return currentClosest;

                if(currentClosest == null || 
                        (currentClosest != null && (Math.abs(currentClosest.data - target) > Math.abs(node.data - target)))) {
                    currentClosest = node;
                }

               if(node.data == target) return node;

                else if(target < node.data) {
                    return findClosestElement(node.left, target, currentClosest);
                }

                else { //target > node.data
                    currentClosest = node;
                    return findClosestElement(node.right, target, currentClosest);
                }
            }

        }

Εδώ είναι η λύση εργασίας σε Java, η οποία χρησιμοποιεί τα χαρακτηριστικά της BST και πρόσθετων ακέραιος να αποθηκεύουν ελάχιστη διαφορά

public class ClosestValueBinaryTree {
        static int closestValue;

        public static void closestValueBST(Node22 node, int target) {
            if (node == null) {
                return;
            }
            if (node.data - target == 0) {
                closestValue = node.data;
                return;
            }
            if (Math.abs(node.data - target) < Math.abs(closestValue - target)) {
                closestValue = node.data;
            }
            if (node.data - target < 0) {
                closestValueBST(node.right, target);
            } else {
                closestValueBST(node.left, target);
            }
        }
    }

Εκτελέστε πολυπλοκότητα χρόνου - O (logN)

χωροχρόνου πολυπλοκότητα - O (1)