En aquest article, parlarem de l'arbre de cerca binari. Aquest article serà molt útil i informatiu per als estudiants amb formació tècnica, ja que és un tema important del seu curs.
Abans de passar directament a l'arbre de cerca binari, primer veiem una breu descripció de l'arbre.
Què és un arbre?
Un arbre és una mena d'estructura de dades que s'utilitza per representar les dades en forma jeràrquica. Es pot definir com una col·lecció d'objectes o entitats anomenades com a nodes que s'uneixen per simular una jerarquia. L'arbre és una estructura de dades no lineal, ja que les dades d'un arbre no s'emmagatzemen de manera lineal o seqüencial.
Ara, comencem el tema, l'arbre de cerca binària.
Què és un arbre de cerca binari?
Un arbre de cerca binari segueix algun ordre per organitzar els elements. En un arbre de cerca binari, el valor del node esquerre ha de ser més petit que el node pare i el valor del node dret ha de ser més gran que el node pare. Aquesta regla s'aplica recursivament als subarbres esquerre i dret de l'arrel.
Entendrem el concepte d'arbre de cerca binari amb un exemple.
A la figura anterior, podem observar que el node arrel és 40, i tots els nodes del subarbre esquerre són més petits que el node arrel, i tots els nodes del subarbre dret són més grans que el node arrel.
De la mateixa manera, podem veure que el fill esquerre del node arrel és més gran que el seu fill esquerre i més petit que el seu fill dret. Per tant, també satisfà la propietat de l'arbre de cerca binari. Per tant, podem dir que l'arbre de la imatge de dalt és un arbre de cerca binari.
Suposem que si canviem el valor del node 35 al 55 a l'arbre anterior, comproveu si l'arbre serà un arbre de cerca binari o no.
A l'arbre anterior, el valor del node arrel és 40, que és més gran que el seu fill esquerre 30 però més petit que el fill dret de 30, és a dir, 55. Per tant, l'arbre anterior no compleix la propietat de l'arbre de cerca binari. Per tant, l'arbre anterior no és un arbre de cerca binari.
Avantatges de l'arbre de cerca binari
- Cercar un element a l'arbre de cerca binari és fàcil, ja que sempre tenim una pista sobre quin subarbre té l'element desitjat.
- En comparació amb la matriu i les llistes enllaçades, les operacions d'inserció i supressió són més ràpides a BST.
Exemple de creació d'un arbre de cerca binari
Ara, vegem la creació d'un arbre de cerca binari amb un exemple.
Suposem que els elements de dades són - 45, 15, 79, 90, 10, 55, 12, 20, 50
- Primer, hem d'inserir 45 a l'arbre com a arrel de l'arbre.
- A continuació, llegiu l'element següent; si és més petit que el node arrel, inseriu-lo com a arrel del subarbre esquerre i aneu a l'element següent.
- En cas contrari, si l'element és més gran que el node arrel, inseriu-lo com a arrel del subarbre dret.
Ara, vegem el procés de creació de l'arbre de cerca binari utilitzant l'element de dades donat. El procés de creació del BST es mostra a continuació:
Pas 1: inseriu 45.
Pas 2: inseriu 15.
Com que 15 és més petit que 45, inseriu-lo com a node arrel del subarbre esquerre.
Pas 3: inseriu 79.
Com que 79 és més gran que 45, inseriu-lo com a node arrel del subarbre dret.
Pas 4: inseriu 90.
90 és més gran que 45 i 79, de manera que s'inserirà com a subarbre dret de 79.
Pas 5: inseriu 10.
L'actriu Sai Pallavi
10 és més petit que 45 i 15, de manera que s'inserirà com a subarbre esquerre de 15.
Pas 6: inseriu 55.
55 és més gran que 45 i més petit que 79, de manera que s'inserirà com a subarbre esquerre de 79.
Pas 7: inseriu 12.
12 és més petit que 45 i 15 però més gran que 10, de manera que s'inserirà com el subarbre dret de 10.
Pas 8: inseriu 20.
20 és més petit que 45 però més gran que 15, de manera que s'inserirà com a subarbre dret de 15.
Pas 9: inseriu 50.
50 és més gran que 45 però més petit que 79 i 55. Per tant, s'inserirà com a subarbre esquerre de 55.
Ara s'ha completat la creació de l'arbre de cerca binari. Després d'això, anem cap a les operacions que es poden realitzar a l'arbre de cerca binari.
Podem realitzar operacions d'inserció, eliminació i cerca a l'arbre de cerca binari.
tutorial de java per a principiants
Entendrem com es realitza una cerca en un arbre de cerca binari.
Cerca a l'arbre de cerca binari
Cercar vol dir trobar o localitzar un element o node específic en una estructura de dades. A l'arbre de cerca binari, cercar un node és fàcil perquè els elements de BST s'emmagatzemen en un ordre específic. Els passos per cercar un node a l'arbre de cerca binària es mostren a continuació:
- Primer, compareu l'element a cercar amb l'element arrel de l'arbre.
- Si l'arrel coincideix amb l'element objectiu, retorneu la ubicació del node.
- Si no coincideix, comproveu si l'element és menor que l'element arrel, si és més petit que l'element arrel, després aneu al subarbre esquerre.
- Si és més gran que l'element arrel, moveu-vos al subarbre dret.
- Repetiu el procediment anterior de manera recursiva fins que es trobi la coincidència.
- Si l'element no es troba o no està present a l'arbre, retorneu NULL.
Ara, anem a entendre la cerca a l'arbre binari amb un exemple. Estem prenent l'arbre de cerca binari format anteriorment. Suposem que hem de trobar el node 20 de l'arbre següent.
Pas 1:
Pas 2:
Pas 3:
Ara, vegem l'algoritme per cercar un element a l'arbre de cerca binari.
Algorisme per cercar un element a l'arbre de cerca binari
Search (root, item) Step 1 - if (item = root → data) or (root = NULL) return root else if (item <root 2 → data) return search(root left, item) else right, end if step - < pre> <p>Now let's understand how the deletion is performed on a binary search tree. We will also see an example to delete an element from the given tree.</p> <h3>Deletion in Binary Search tree</h3> <p>In a binary search tree, we must delete a node from the tree by keeping in mind that the property of BST is not violated. To delete a node from BST, there are three possible situations occur -</p> <ul> <li>The node to be deleted is the leaf node, or,</li> <li>The node to be deleted has only one child, and,</li> <li>The node to be deleted has two children</li> </ul> <p>We will understand the situations listed above in detail.</p> <p> <strong>When the node to be deleted is the leaf node</strong> </p> <p>It is the simplest case to delete a node in BST. Here, we have to replace the leaf node with NULL and simply free the allocated space.</p> <p>We can see the process to delete a leaf node from BST in the below image. In below image, suppose we have to delete node 90, as the node to be deleted is a leaf node, so it will be replaced with NULL, and the allocated space will free.</p> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-15.webp" alt="Binary Search tree"> <p> <strong>When the node to be deleted has only one child</strong> </p> <p>In this case, we have to replace the target node with its child, and then delete the child node. It means that after replacing the target node with its child node, the child node will now contain the value to be deleted. So, we simply have to replace the child node with NULL and free up the allocated space.</p> <p>We can see the process of deleting a node with one child from BST in the below image. In the below image, suppose we have to delete the node 79, as the node to be deleted has only one child, so it will be replaced with its child 55.</p> <p>So, the replaced node 79 will now be a leaf node that can be easily deleted.</p> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-16.webp" alt="Binary Search tree"> <p> <strong>When the node to be deleted has two children</strong> </p> <p>This case of deleting a node in BST is a bit complex among other two cases. In such a case, the steps to be followed are listed as follows -</p> <ul> <li>First, find the inorder successor of the node to be deleted.</li> <li>After that, replace that node with the inorder successor until the target node is placed at the leaf of tree.</li> <li>And at last, replace the node with NULL and free up the allocated space.</li> </ul> <p>The inorder successor is required when the right child of the node is not empty. We can obtain the inorder successor by finding the minimum element in the right child of the node.</p> <p>We can see the process of deleting a node with two children from BST in the below image. In the below image, suppose we have to delete node 45 that is the root node, as the node to be deleted has two children, so it will be replaced with its inorder successor. Now, node 45 will be at the leaf of the tree so that it can be deleted easily.</p> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-17.webp" alt="Binary Search tree"> <p>Now let's understand how insertion is performed on a binary search tree.</p> <h3>Insertion in Binary Search tree</h3> <p>A new key in BST is always inserted at the leaf. To insert an element in BST, we have to start searching from the root node; if the node to be inserted is less than the root node, then search for an empty location in the left subtree. Else, search for the empty location in the right subtree and insert the data. Insert in BST is similar to searching, as we always have to maintain the rule that the left subtree is smaller than the root, and right subtree is larger than the root.</p> <p>Now, let's see the process of inserting a node into BST using an example.</p> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-18.webp" alt="Binary Search tree"> <br> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-19.webp" alt="Binary Search tree"> <h3>The complexity of the Binary Search tree</h3> <p>Let's see the time and space complexity of the Binary search tree. We will see the time complexity for insertion, deletion, and searching operations in best case, average case, and worst case.</p> <h3>1. Time Complexity</h3> <table class="table"> <tr> <th>Operations</th> <th>Best case time complexity</th> <th>Average case time complexity</th> <th>Worst case time complexity</th> </tr> <tr> <td> <strong>Insertion</strong> </td> <td>O(log n)</td> <td>O(log n)</td> <td>O(n)</td> </tr> <tr> <td> <strong>Deletion</strong> </td> <td>O(log n)</td> <td>O(log n)</td> <td>O(n)</td> </tr> <tr> <td> <strong>Search</strong> </td> <td>O(log n)</td> <td>O(log n)</td> <td>O(n)</td> </tr> </table> <p>Where 'n' is the number of nodes in the given tree.</p> <h3>2. Space Complexity</h3> <table class="table"> <tr> <th>Operations</th> <th>Space complexity</th> </tr> <tr> <td> <strong>Insertion</strong> </td> <td>O(n)</td> </tr> <tr> <td> <strong>Deletion</strong> </td> <td>O(n)</td> </tr> <tr> <td> <strong>Search</strong> </td> <td>O(n)</td> </tr> </table> <ul> <li>The space complexity of all operations of Binary search tree is O(n).</li> </ul> <h2>Implementation of Binary search tree</h2> <p>Now, let's see the program to implement the operations of Binary Search tree.</p> <p> <strong>Program:</strong> Write a program to perform operations of Binary Search tree in C++.</p> <p>In this program, we will see the implementation of the operations of binary search tree. Here, we will see the creation, inorder traversal, insertion, and deletion operations of tree.</p> <p>Here, we will see the inorder traversal of the tree to check whether the nodes of the tree are in their proper location or not. We know that the inorder traversal always gives us the data in ascending order. So, after performing the insertion and deletion operations, we perform the inorder traversal, and after traversing, if we get data in ascending order, then it is clear that the nodes are in their proper location.</p> <pre> #include using namespace std; struct Node { int data; Node *left; Node *right; }; Node* create(int item) { Node* node = new Node; node->data = item; node->left = node->right = NULL; return node; } /*Inorder traversal of the tree formed*/ void inorder(Node *root) { if (root == NULL) return; inorder(root->left); //traverse left subtree cout<data <right); traverse right subtree } node* findminimum(node* cur) *to find the inorder successor* { while(cur->left != NULL) { cur = cur->left; } return cur; } Node* insertion(Node* root, int item) /*Insert a node*/ { if (root == NULL) return create(item); /*return new node if tree is empty*/ if (item data) root->left = insertion(root->left, item); else root->right = insertion(root->right, item); return root; } void search(Node* &cur, int item, Node* &parent) { while (cur != NULL && cur->data != item) { parent = cur; if (item data) cur = cur->left; else cur = cur->right; } } void deletion(Node*& root, int item) /*function to delete a node*/ { Node* parent = NULL; Node* cur = root; search(cur, item, parent); /*find the node to be deleted*/ if (cur == NULL) return; if (cur->left == NULL && cur->right == NULL) /*When node has no children*/ { if (cur != root) { if (parent->left == cur) parent->left = NULL; else parent->right = NULL; } else root = NULL; free(cur); } else if (cur->left && cur->right) { Node* succ = findMinimum(cur->right); int val = succ->data; deletion(root, succ->data); cur->data = val; } else { Node* child = (cur->left)? cur->left: cur->right; if (cur != root) { if (cur == parent->left) parent->left = child; else parent->right = child; } else root = child; free(cur); } } int main() { Node* root = NULL; root = insertion(root, 45); root = insertion(root, 30); root = insertion(root, 50); root = insertion(root, 25); root = insertion(root, 35); root = insertion(root, 45); root = insertion(root, 60); root = insertion(root, 4); printf('The inorder traversal of the given binary tree is -
'); inorder(root); deletion(root, 25); printf('
After deleting node 25, the inorder traversal of the given binary tree is -
'); inorder(root); insertion(root, 2); printf('
After inserting node 2, the inorder traversal of the given binary tree is -
'); inorder(root); return 0; } </data></pre> <p> <strong>Output</strong> </p> <p>After the execution of the above code, the output will be -</p> <img src="//techcodeview.com/img/ds-tutorial/58/binary-search-tree-20.webp" alt="Binary Search tree"> <p>So, that's all about the article. Hope the article will be helpful and informative to you.</p> <hr></root> Sortida
Després de l'execució del codi anterior, la sortida serà -
Per tant, això és tot sobre l'article. Espero que l'article us sigui útil i informatiu.