使用delete关键字删除二叉树-yiteyi-C++库

A. 递归的还有非递归删除整个二叉树的程序已经在前面的文章中讨论过了。在本文中，使用删去讨论了C++中的关键词。

null

申报 析构函数 “BinaryTreeNode”类中的函数，该类已定义为创建树节点。对类的对象使用“delete”关键字会删除整个二叉树。，它的析构函数在析构函数中调用。使用 “删除” 孩子们的关键词；因此，子级的析构函数将被逐个调用，这个过程将递归进行，直到整个二叉树被删除。考虑下面所示的树，一旦对根调用析构函数，即“1”，它将调用“2”和“3”的析构函数，然后2将分别用其“4”和“5”对其左、右子调用相同的函数。最终，该树将按以下顺序删除： 4->5->2->3->1 （邮购）

图片[1]-使用delete关键字删除二叉树-yiteyi-C++库

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

下面是C++实现上述方法：

                     // C++ program to delete the entire binary                   
                     // tree using the delete keyword                   
                     #include <iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               BinaryTreeNode {                   
                             
                                         // Making data members public to                   
                                         // avoid the usage of getter and setter functions                   
                     public                               :                   
                                         int                               data;                   
                                         BinaryTreeNode* left;                   
                                         BinaryTreeNode* right;                   
                             
                                         // Constructor function to                   
                                         // assign data to the node                   
                                         BinaryTreeNode(                               int                               data)                   
                                         {                   
                                         this                               ->data = data;                   
                                         this                               ->left = NULL;                   
                                         this                               ->right = NULL;                   
                                         }                   
                             
                                         // Destructor function to delete the tree                   
                                         ~BinaryTreeNode()                   
                                         {                   
                                         // using keyword to delete the tree                   
                                         delete                               left;                   
                                         delete                               right;                   
                             
                                         // printing the node which has been deleted                   
                                         cout <<                               "Deleting "                               <<                               this                               ->data << endl;                   
                                         }                   
                     };                   
                             
                     // Driver Code                   
                     int                               main()                   
                     {                   
                                         // Creating the nodes dynamically                   
                                         BinaryTreeNode* root =                               new                               BinaryTreeNode(1);                   
                                         BinaryTreeNode* node1 =                               new                               BinaryTreeNode(2);                   
                                         BinaryTreeNode* node2 =                               new                               BinaryTreeNode(3);                   
                                         BinaryTreeNode* node3 =                               new                               BinaryTreeNode(4);                   
                                         BinaryTreeNode* node4 =                               new                               BinaryTreeNode(5);                   
                             
                                         // Creating the binary tree                   
                                         root->left = node1;                   
                                         root->right = node2;                   
                                         node1->left = node3;                   
                                         node1->right = node4;                   
                             
                                         // Calls the destructor function which actually deletes the tree entirely                   
                                         delete                               root;                   
                             
                                         return                               0;                   
                     }                   

输出：

Deleting 4
Deleting 5
Deleting 2
Deleting 3
Deleting 1

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章