Δέντρο AVL

Σε αυτό το σεμινάριο, θα μάθετε τι είναι ένα δέντρο avl. Επίσης, θα βρείτε παραδείγματα εργασίας διαφόρων λειτουργιών που εκτελούνται σε ένα δέντρο avl σε C, C ++, Java και Python.

Το δέντρο AVL είναι ένα δέντρο εξισορρόπησης δυαδικής αναζήτησης στο οποίο κάθε κόμβος διατηρεί επιπλέον πληροφορίες που ονομάζονται συντελεστής ισορροπίας, η τιμή του οποίου είναι -1, 0 ή +1.

Το δέντρο AVL πήρε το όνομά του από τους εφευρέτες του Georgy Adelson-Velsky και Landis.

Συντελεστής ισορροπίας

Ο συντελεστής ισορροπίας ενός κόμβου σε ένα δέντρο AVL είναι η διαφορά μεταξύ του ύψους του αριστερού υποδέντρου και εκείνου του δεξιού υποδέντρου αυτού του κόμβου.

Συντελεστής ισορροπίας = (Ύψος αριστερού υποδέντρου - Ύψος δεξιού υποδέντρου) ή (Ύψος δεξιού υποδέντρου - Ύψος αριστερού υποδέντρου)

Η ιδιότητα εξισορρόπησης ενός δέντρου avl διατηρείται από τον παράγοντα ισορροπίας. Η τιμή του συντελεστή ισορροπίας πρέπει πάντα να είναι -1, 0 ή +1.

Ένα παράδειγμα ισορροπημένου avl δέντρου είναι:

Avl δέντρο

Λειτουργίες σε ένα δέντρο AVL

Διάφορες λειτουργίες που μπορούν να εκτελεστούν σε ένα δέντρο AVL είναι:

Περιστροφή των υποδέντρων σε ένα δέντρο AVL

Κατά τη λειτουργία περιστροφής, οι θέσεις των κόμβων ενός υποδέντρου ανταλλάσσονται.

Υπάρχουν δύο τύποι περιστροφών:

Αριστερή περιστροφή

Στην αριστερή περιστροφή, η διάταξη των κόμβων στα δεξιά μετατρέπεται σε διευθετήσεις στον αριστερό κόμβο.

Αλγόριθμος

  1. Αφήστε το αρχικό δέντρο να είναι: Αριστερά περιστροφή
  2. Εάν το y έχει ένα αριστερό υποδένδρο, αντιστοιχίστε το x ως γονικό στοιχείο του αριστερού υποδέντρου του y Αντιστοιχίστε το x ως γονέα του αριστερού δευτερεύοντος δέντρου του y
  3. Εάν ο γονέας του x είναι NULL, ορίστε το y ως τη ρίζα του δέντρου.
  4. Διαφορετικά, αν το x είναι το αριστερό παιδί του p, κάντε το y ως το αριστερό παιδί του p.
  5. Αλλιώς ορίστε y ως το σωστό παιδί της σελ. Αλλάξτε το γονικό του x σε αυτό του y
  6. Κάντε y ως γονέα του x. Αντιστοιχίστε το y ως το γονικό του x.

Δεξιά περιστροφή

Στην αριστερή περιστροφή, η διάταξη των κόμβων στα αριστερά μετατρέπεται σε διευθετήσεις στον δεξιό κόμβο.

  1. Αφήστε το αρχικό δέντρο να είναι: Αρχικό δέντρο
  2. Εάν το x έχει ένα σωστό υποδένδρο, εκχωρήστε το y ως το γονικό του σωστού υποδέντρου του x Αντιστοιχίστε το y ως το γονικό του σωστού δευτερεύοντος δέντρου του x
  3. Εάν ο γονέας του y είναι NULL, κάντε το x ως τη ρίζα του δέντρου.
  4. Διαφορετικά εάν το y είναι το σωστό παιδί του γονέα του p, κάντε το x ως το σωστό παιδί του p.
  5. Αλλιώς ορίστε το x ως το αριστερό παιδί του σελ. Αντιστοιχίστε τον γονέα του y ως τον γονέα του x.
  6. Κάντε το x ως γονέα του y. Αντιστοιχίστε το x ως γονέα του y

Περιστροφή αριστερά-δεξιά και δεξιά-αριστερά

Στην περιστροφή αριστερά-δεξιά, οι ρυθμίσεις μετατοπίζονται πρώτα προς τα αριστερά και μετά προς τα δεξιά.

  1. Κάντε αριστερή περιστροφή στο xy. Αριστερή περιστροφή xy
  2. Κάντε τη σωστή περιστροφή στο yz. Περιστρέψτε δεξιά zy

Στην περιστροφή δεξιά-αριστερά, οι ρυθμίσεις μετατοπίζονται πρώτα προς τα δεξιά και μετά προς τα αριστερά.

  1. Κάντε σωστή περιστροφή στο xy. Περιστρέψτε δεξιά xy
  2. Κάντε αριστερή περιστροφή στο zy. Αριστερή περιστροφή zy

Αλγόριθμος για εισαγωγή ενός νέου κόμβου

Ένας νέος κόμβος εισάγεται πάντα ως κόμβος φύλλων με συντελεστή ισορροπίας ίσο με 0.

  1. Αφήστε το αρχικό δέντρο να είναι: Αρχικό δέντρο για εισαγωγή
    Αφήστε τον κόμβο που θα εισαχθεί να είναι: Νέος κόμβος
  2. Μεταβείτε στον κατάλληλο κόμβο φύλλων για να εισαγάγετε έναν νέο κόμβο χρησιμοποιώντας τα ακόλουθα αναδρομικά βήματα. Συγκρίνετε το newKey με το rootKey του τρέχοντος δέντρου.
    1. Εάν το newKey <rootKey, καλέστε τον αλγόριθμο εισαγωγής στο αριστερό υπόστρωμα του τρέχοντος κόμβου έως ότου επιτευχθεί ο κόμβος φύλλων.
    2. Διαφορετικά εάν newKey> rootKey, αλγόριθμος εισαγωγής κλήσεων στο δεξιό υπόγειο του τρέχοντος κόμβου έως ότου επιτευχθεί ο κόμβος φύλλων.
    3. Διαφορετικά, επιστροφή φύλλου κόμβου. Εύρεση της τοποθεσίας για εισαγωγή newNode
  3. Συγκρίνετε το leafKey που αποκτήθηκε από τα παραπάνω βήματα με το newKey:
    1. Εάν newKey <leafKey, κάντε το newNode ως το αριστερό παιδί του φύλλου.
    2. Διαφορετικά, κάντε το newNode ως δεξί παιδί του φύλλου. Εισαγωγή του νέου κόμβου
  4. Ενημέρωση balanceFactor των κόμβων. Ενημέρωση του συντελεστή υπολοίπου μετά την εισαγωγή
  5. Εάν οι κόμβοι δεν είναι ισορροπημένοι, τότε ισορροπήστε ξανά τον κόμβο.
    1. Εάν το balanceFactor> 1, αυτό σημαίνει ότι το ύψος του αριστερού υποδέντρου είναι μεγαλύτερο από αυτό του δεξιού υποδέντρου. Έτσι, κάντε μια δεξιά περιστροφή ή αριστερή-δεξιά περιστροφή
      1. Εάν το newNodeKey <leftChildKey κάνει τη σωστή περιστροφή.
      2. Διαφορετικά, κάντε περιστροφή αριστερά-δεξιά. Εξισορρόπηση του δέντρου με περιστροφή Ισορροπία του δέντρου με περιστροφή
    2. Εάν το balanceFactor <-1, αυτό σημαίνει ότι το ύψος του δεξιού υποδέντρου είναι μεγαλύτερο από αυτό του αριστερού υποδέντρου. Λοιπόν, κάντε δεξιά περιστροφή ή δεξιά-αριστερή περιστροφή
      1. Εάν newNodeKey> rightChildKey κάνετε αριστερή περιστροφή.
      2. Αλλιώς, κάντε περιστροφή δεξιά-αριστερά
  6. Το τελικό δέντρο είναι: Τελικό ισορροπημένο δέντρο

Αλγόριθμος για διαγραφή ενός κόμβου

Ένας κόμβος διαγράφεται πάντα ως κόμβος φύλλων. Μετά τη διαγραφή ενός κόμβου, οι παράγοντες ισορροπίας των κόμβων αλλάζουν. Για την εξισορρόπηση του συντελεστή ισορροπίας, πραγματοποιούνται κατάλληλες περιστροφές.

  1. Εντοπίστε το nodeToBeDeleted (η αναδρομή χρησιμοποιείται για να βρείτε το nodeToBeDeleted στον κώδικα που χρησιμοποιείται παρακάτω). Εντοπισμός του κόμβου προς διαγραφή
  2. Υπάρχουν τρεις περιπτώσεις για τη διαγραφή ενός κόμβου:
    1. Εάν ο κόμβος nodeToBeDeleted είναι ο κόμβος των φύλλων (δηλαδή δεν έχει κανένα παιδί), τότε αφαιρέστε το nodeToBeDeleted.
    2. Εάν το nodeToBeDeleted έχει ένα παιδί, τότε αντικαταστήστε το περιεχόμενο του nodeToBeDeleted με αυτό του παιδιού. Αφαιρέστε το παιδί.
    3. Εάν το nodeToBeDeleted έχει δύο παιδιά, βρείτε τον διάδοχο διάδοχο του nodeToBeDeleted (δηλ. Κόμβος με ελάχιστη τιμή κλειδιού στο δεξιό υποδένδρο). Εύρεση του διαδόχου
      1. Αντικαταστήστε τα περιεχόμενα του nodeToBeDeleted με αυτό του w. Αντικαταστήστε τον κόμβο που θα διαγραφεί
      2. Αφαιρέστε τον κόμβο φύλλων w. Αφαιρέστε w
  3. Ενημέρωση balanceFactor των κόμβων. Ενημέρωση bf
  4. Εξισορροπήστε ξανά το δέντρο εάν ο συντελεστής ισορροπίας οποιουδήποτε από τους κόμβους δεν είναι ίσος με -1, 0 ή 1.
    1. Εάν balanceFactor του currentNode> 1,
      1. Εάν balanceFactor of leftChild> = 0, κάντε δεξιά περιστροφή. Περιστρέψτε δεξιά για εξισορρόπηση του δέντρου
      2. Αλλιώς κάνετε περιστροφή αριστερά-δεξιά.
    2. If balanceFactor του currentNode <-1,
      1. Εάν balanceFactor of rightChild <= 0, κάντε αριστερή περιστροφή.
      2. Διαφορετικά κάντε περιστροφή δεξιά-αριστερά.
  5. Το τελικό δέντρο είναι: Avl final final

Παραδείγματα Python, Java και C / C ++

Python Java C C ++ 
 # AVL tree implementation in Python import sys # Create a tree node class TreeNode(object): def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 class AVLTree(object): # Function to insert a node def insert_node(self, root, key): # Find the correct location and insert the node if not root: return TreeNode(key) elif key 1: if key < root.left.key: return self.rightRotate(root) else: root.left = self.leftRotate(root.left) return self.rightRotate(root) if balanceFactor root.right.key: return self.leftRotate(root) else: root.right = self.rightRotate(root.right) return self.leftRotate(root) return root # Function to delete a node def delete_node(self, root, key): # Find the node to be deleted and remove it if not root: return root elif key root.key: root.right = self.delete_node(root.right, key) else: if root.left is None: temp = root.right root = None return temp elif root.right is None: temp = root.left root = None return temp temp = self.getMinValueNode(root.right) root.key = temp.key root.right = self.delete_node(root.right, temp.key) if root is None: return root # Update the balance factor of nodes root.height = 1 + max(self.getHeight(root.left), self.getHeight(root.right)) balanceFactor = self.getBalance(root) # Balance the tree if balanceFactor> 1: if self.getBalance(root.left)>= 0: return self.rightRotate(root) else: root.left = self.leftRotate(root.left) return self.rightRotate(root) if balanceFactor < -1: if self.getBalance(root.right) <= 0: return self.leftRotate(root) else: root.right = self.rightRotate(root.right) return self.leftRotate(root) return root # Function to perform left rotation def leftRotate(self, z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = 1 + max(self.getHeight(z.left), self.getHeight(z.right)) y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right)) return y # Function to perform right rotation def rightRotate(self, z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = 1 + max(self.getHeight(z.left), self.getHeight(z.right)) y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right)) return y # Get the height of the node def getHeight(self, root): if not root: return 0 return root.height # Get balance factore of the node def getBalance(self, root): if not root: return 0 return self.getHeight(root.left) - self.getHeight(root.right) def getMinValueNode(self, root): if root is None or root.left is None: return root return self.getMinValueNode(root.left) def preOrder(self, root): if not root: return print("(0) ".format(root.key), end="") self.preOrder(root.left) self.preOrder(root.right) # Print the tree def printHelper(self, currPtr, indent, last): if currPtr != None: sys.stdout.write(indent) if last: sys.stdout.write("R----") indent += " " else: sys.stdout.write("L----") indent += "| " print(currPtr.key) self.printHelper(currPtr.left, indent, False) self.printHelper(currPtr.right, indent, True) myTree = AVLTree() root = None nums = (33, 13, 52, 9, 21, 61, 8, 11) for num in nums: root = myTree.insert_node(root, num) myTree.printHelper(root, "", True) key = 13 root = myTree.delete_node(root, key) print("After Deletion: ") myTree.printHelper(root, "", True)
 // AVL tree implementation in Java // Create node class Node ( int item, height; Node left, right; Node(int d) ( item = d; height = 1; ) ) // Tree class class AVLTree ( Node root; int height(Node N) ( if (N == null) return 0; return N.height; ) int max(int a, int b) ( return (a> b) ? a : b; ) Node rightRotate(Node y) ( Node x = y.left; Node T2 = x.right; x.right = y; y.left = T2; y.height = max(height(y.left), height(y.right)) + 1; x.height = max(height(x.left), height(x.right)) + 1; return x; ) Node leftRotate(Node x) ( Node y = x.right; Node T2 = y.left; y.left = x; x.right = T2; x.height = max(height(x.left), height(x.right)) + 1; y.height = max(height(y.left), height(y.right)) + 1; return y; ) // Get balance factor of a node int getBalanceFactor(Node N) ( if (N == null) return 0; return height(N.left) - height(N.right); ) // Insert a node Node insertNode(Node node, int item) ( // Find the position and insert the node if (node == null) return (new Node(item)); if (item node.item) node.right = insertNode(node.right, item); else return node; // Update the balance factor of each node // And, balance the tree node.height = 1 + max(height(node.left), height(node.right)); int balanceFactor = getBalanceFactor(node); if (balanceFactor> 1) ( if (item node.left.item) ( node.left = leftRotate(node.left); return rightRotate(node); ) ) if (balanceFactor node.right.item) ( return leftRotate(node); ) else if (item < node.right.item) ( node.right = rightRotate(node.right); return leftRotate(node); ) ) return node; ) Node nodeWithMimumValue(Node node) ( Node current = node; while (current.left != null) current = current.left; return current; ) // Delete a node Node deleteNode(Node root, int item) ( // Find the node to be deleted and remove it if (root == null) return root; if (item root.item) root.right = deleteNode(root.right, item); else ( if ((root.left == null) || (root.right == null)) ( Node temp = null; if (temp == root.left) temp = root.right; else temp = root.left; if (temp == null) ( temp = root; root = null; ) else root = temp; ) else ( Node temp = nodeWithMimumValue(root.right); root.item = temp.item; root.right = deleteNode(root.right, temp.item); ) ) if (root == null) return root; // Update the balance factor of each node and balance the tree root.height = max(height(root.left), height(root.right)) + 1; int balanceFactor = getBalanceFactor(root); if (balanceFactor> 1) ( if (getBalanceFactor(root.left)>= 0) ( return rightRotate(root); ) else ( root.left = leftRotate(root.left); return rightRotate(root); ) ) if (balanceFactor < -1) ( if (getBalanceFactor(root.right) <= 0) ( return leftRotate(root); ) else ( root.right = rightRotate(root.right); return leftRotate(root); ) ) return root; ) void preOrder(Node node) ( if (node != null) ( System.out.print(node.item + " "); preOrder(node.left); preOrder(node.right); ) ) // Print the tree private void printTree(Node currPtr, String indent, boolean last) ( if (currPtr != null) ( System.out.print(indent); if (last) ( System.out.print("R----"); indent += " "; ) else ( System.out.print("L----"); indent += "| "; ) System.out.println(currPtr.item); printTree(currPtr.left, indent, false); printTree(currPtr.right, indent, true); ) ) // Driver code public static void main(String() args) ( AVLTree tree = new AVLTree(); tree.root = tree.insertNode(tree.root, 33); tree.root = tree.insertNode(tree.root, 13); tree.root = tree.insertNode(tree.root, 53); tree.root = tree.insertNode(tree.root, 9); tree.root = tree.insertNode(tree.root, 21); tree.root = tree.insertNode(tree.root, 61); tree.root = tree.insertNode(tree.root, 8); tree.root = tree.insertNode(tree.root, 11); tree.printTree(tree.root, "", true); tree.root = tree.deleteNode(tree.root, 13); System.out.println("After Deletion: "); tree.printTree(tree.root, "", true); ) )
 // AVL tree implementation in C #include #include // Create Node struct Node ( int key; struct Node *left; struct Node *right; int height; ); int max(int a, int b); // Calculate height int height(struct Node *N) ( if (N == NULL) return 0; return N->height; ) int max(int a, int b) ( return (a> b) ? a : b; ) // Create a node struct Node *newNode(int key) ( struct Node *node = (struct Node *) malloc(sizeof(struct Node)); node->key = key; node->left = NULL; node->right = NULL; node->height = 1; return (node); ) // Right rotate struct Node *rightRotate(struct Node *y) ( struct Node *x = y->left; struct Node *T2 = x->right; x->right = y; y->left = T2; y->height = max(height(y->left), height(y->right)) + 1; x->height = max(height(x->left), height(x->right)) + 1; return x; ) // Left rotate struct Node *leftRotate(struct Node *x) ( struct Node *y = x->right; struct Node *T2 = y->left; y->left = x; x->right = T2; x->height = max(height(x->left), height(x->right)) + 1; y->height = max(height(y->left), height(y->right)) + 1; return y; ) // Get the balance factor int getBalance(struct Node *N) ( if (N == NULL) return 0; return height(N->left) - height(N->right); ) // Insert node struct Node *insertNode(struct Node *node, int key) ( // Find the correct position to insertNode the node and insertNode it if (node == NULL) return (newNode(key)); if (key key) node->left = insertNode(node->left, key); else if (key> node->key) node->right = insertNode(node->right, key); else return node; // Update the balance factor of each node and // Balance the tree node->height = 1 + max(height(node->left), height(node->right)); int balance = getBalance(node); if (balance> 1 && key left->key) return rightRotate(node); if (balance node->right->key) return leftRotate(node); if (balance> 1 && key> node->left->key) ( node->left = leftRotate(node->left); return rightRotate(node); ) if (balance < -1 && key right->key) ( node->right = rightRotate(node->right); return leftRotate(node); ) return node; ) struct Node *minValueNode(struct Node *node) ( struct Node *current = node; while (current->left != NULL) current = current->left; return current; ) // Delete a nodes struct Node *deleteNode(struct Node *root, int key) ( // Find the node and delete it if (root == NULL) return root; if (key key) root->left = deleteNode(root->left, key); else if (key> root->key) root->right = deleteNode(root->right, key); else ( if ((root->left == NULL) || (root->right == NULL)) ( struct Node *temp = root->left ? root->left : root->right; if (temp == NULL) ( temp = root; root = NULL; ) else *root = *temp; free(temp); ) else ( struct Node *temp = minValueNode(root->right); root->key = temp->key; root->right = deleteNode(root->right, temp->key); ) ) if (root == NULL) return root; // Update the balance factor of each node and // balance the tree root->height = 1 + max(height(root->left), height(root->right)); int balance = getBalance(root); if (balance> 1 && getBalance(root->left)>= 0) return rightRotate(root); if (balance> 1 && getBalance(root->left) left = leftRotate(root->left); return rightRotate(root); ) if (balance right) <= 0) return leftRotate(root); if (balance right)> 0) ( root->right = rightRotate(root->right); return leftRotate(root); ) return root; ) // Print the tree void printPreOrder(struct Node *root) ( if (root != NULL) ( printf("%d ", root->key); printPreOrder(root->left); printPreOrder(root->right); ) ) int main() ( struct Node *root = NULL; root = insertNode(root, 2); root = insertNode(root, 1); root = insertNode(root, 7); root = insertNode(root, 4); root = insertNode(root, 5); root = insertNode(root, 3); root = insertNode(root, 8); printPreOrder(root); root = deleteNode(root, 3); printf("After deletion: "); printPreOrder(root); return 0; )
 // AVL tree implementation in C++ #include using namespace std; class Node ( public: int key; Node *left; Node *right; int height; ); int max(int a, int b); // Calculate height int height(Node *N) ( if (N == NULL) return 0; return N->height; ) int max(int a, int b) ( return (a> b) ? a : b; ) // New node creation Node *newNode(int key) ( Node *node = new Node(); node->key = key; node->left = NULL; node->right = NULL; node->height = 1; return (node); ) // Rotate right Node *rightRotate(Node *y) ( Node *x = y->left; Node *T2 = x->right; x->right = y; y->left = T2; y->height = max(height(y->left), height(y->right)) + 1; x->height = max(height(x->left), height(x->right)) + 1; return x; ) // Rotate left Node *leftRotate(Node *x) ( Node *y = x->right; Node *T2 = y->left; y->left = x; x->right = T2; x->height = max(height(x->left), height(x->right)) + 1; y->height = max(height(y->left), height(y->right)) + 1; return y; ) // Get the balance factor of each node int getBalanceFactor(Node *N) ( if (N == NULL) return 0; return height(N->left) - height(N->right); ) // Insert a node Node *insertNode(Node *node, int key) ( // Find the correct postion and insert the node if (node == NULL) return (newNode(key)); if (key key) node->left = insertNode(node->left, key); else if (key> node->key) node->right = insertNode(node->right, key); else return node; // Update the balance factor of each node and // balance the tree node->height = 1 + max(height(node->left), height(node->right)); int balanceFactor = getBalanceFactor(node); if (balanceFactor> 1) ( if (key left->key) ( return rightRotate(node); ) else if (key> node->left->key) ( node->left = leftRotate(node->left); return rightRotate(node); ) ) if (balanceFactor node->right->key) ( return leftRotate(node); ) else if (key right->key) ( node->right = rightRotate(node->right); return leftRotate(node); ) ) return node; ) // Node with minimum value Node *nodeWithMimumValue(Node *node) ( Node *current = node; while (current->left != NULL) current = current->left; return current; ) // Delete a node Node *deleteNode(Node *root, int key) ( // Find the node and delete it if (root == NULL) return root; if (key key) root->left = deleteNode(root->left, key); else if (key> root->key) root->right = deleteNode(root->right, key); else ( if ((root->left == NULL) || (root->right == NULL)) ( Node *temp = root->left ? root->left : root->right; if (temp == NULL) ( temp = root; root = NULL; ) else *root = *temp; free(temp); ) else ( Node *temp = nodeWithMimumValue(root->right); root->key = temp->key; root->right = deleteNode(root->right, temp->key); ) ) if (root == NULL) return root; // Update the balance factor of each node and // balance the tree root->height = 1 + max(height(root->left), height(root->right)); int balanceFactor = getBalanceFactor(root); if (balanceFactor> 1) ( if (getBalanceFactor(root->left)>= 0) ( return rightRotate(root); ) else ( root->left = leftRotate(root->left); return rightRotate(root); ) ) if (balanceFactor right) right = rightRotate(root->right); return leftRotate(root); ) ) return root; ) // Print the tree void printTree(Node *root, string indent, bool last) ( if (root != nullptr) ( cout << indent; if (last) ( cout << "R----"; indent += " "; ) else ( cout << "L----"; indent += "| "; ) cout  right, indent, true); ) ) int main() ( Node *root = NULL; root = insertNode(root, 33); root = insertNode(root, 13); root = insertNode(root, 53); root = insertNode(root, 9); root = insertNode(root, 21); root = insertNode(root, 61); root = insertNode(root, 8); root = insertNode(root, 11); printTree(root, "", true); root = deleteNode(root, 13); cout << "After deleting " << endl; printTree(root, "", true); )

Πολυπλοκότητες διαφορετικών λειτουργιών σε ένα δέντρο AVL

Εισαγωγή Διαγραφή Αναζήτηση
O (ημερολόγιο n) O (ημερολόγιο n) O (ημερολόγιο n)

Εφαρμογές AVL Tree

  • Για ευρετηρίαση μεγάλων εγγραφών σε βάσεις δεδομένων
  • Για αναζήτηση σε μεγάλες βάσεις δεδομένων

ενδιαφέροντα άρθρα...