C++程序中二叉树的删除操作


在本教程中,我们将学习如何在二叉树中删除节点。

二叉树中的节点不像二叉搜索树那样遵循任何顺序。那么,如何在删除二叉树中的节点后重新排列节点呢?

我们将用树中最深的节点替换要删除的节点。然后我们将从节点中删除最深的节点。

让我们看看解决问题的步骤。

  • 用二叉节点结构初始化树。

  • 编写一个函数(前序、中序和后序)来打印树的节点。

  • 编写一个函数来删除节点。

    • 初始化一个队列来遍历树。

    • 迭代直到队列为空。

    • 找到具有给定键的节点并将其存储在一个变量中。

    • 队列中的最后一个节点是最深的节点。

  • 使用另一个函数删除最深的节点。

    • 使用队列遍历树。

    • 当我们找到要删除的节点时,删除它并返回它。

  • 打印树以查看节点是否已删除。

示例

让我们看看代码。

 在线演示

#include <bits/stdc++.h>
using namespace std;
struct Node {
   int data;
   struct Node *left, *right;
};
struct Node* newNode(int data) {
   struct Node* temp = new Node;
   temp->data = data;
   temp->left = temp->right = NULL;
   return temp;
};
void inorder(struct Node* node) {
   if (node == NULL) {
      return;
   }
   inorder(node->left);
   cout << node->data << " ";
   inorder(node->right);
}
void deleteDeepestNode(struct Node* root, struct Node* deleting_node){
   queue<struct Node*> nodes;
   nodes.push(root);
   struct Node* temp;
   while (!nodes.empty()) {
      temp = nodes.front();
      nodes.pop();
      if (temp == deleting_node) {
         temp = NULL;
         delete (deleting_node);
         return;
      }
      if (temp->right) {
         if (temp->right == deleting_node) {
            temp->right = NULL;
            delete deleting_node;
            return;
         }
         else {
            nodes.push(temp->right);
         }
      }
      if (temp->left) {
         if (temp->left == deleting_node) {
            temp->left = NULL;
            delete deleting_node;
            return;
         }
         else {
            nodes.push(temp->left);
         }
      }
   }
}
Node* deleteNode(struct Node* root, int key) {
   if (root == NULL){
      return NULL;
   }
   if (root->left == NULL && root->right == NULL) {
      if (root->data == key) {
         return NULL;
      }
      else {
         return root;
      }
   }
   queue<struct Node*> nodes;
   nodes.push(root);
   struct Node* temp;
   struct Node* key_node = NULL;
   while (!nodes.empty()) {
      temp = nodes.front();
      nodes.pop();
      if (temp->data == key) {
         key_node = temp;
      }
      if (temp->left) {
         nodes.push(temp->left);
      }
      if (temp->right) {
         nodes.push(temp->right);
      }
   }
   if (key_node != NULL) {
      int deepest_node_data = temp->data;
      deleteDeepestNode(root, temp);
      key_node->data = deepest_node_data;
   }
   return root;
}
int main() {
   struct Node* root = newNode(1);
   root->left = newNode(2);
   root->left->left = newNode(3);
   root->left->right = newNode(4);
   root->right = newNode(5);
   root->right->left = newNode(6);
   root->right->right = newNode(7);
   root->right->left->left = newNode(8);
   root->right->left->right = newNode(9);
   cout << "Tree before deleting key: ";
   inorder(root);
   int key = 5;
   root = deleteNode(root, key);
   cout << "\nTree after deleting key: ";
   inorder(root);
   cout << endl;
   return 0;
}

输出

如果您运行上面的代码,您将得到以下结果。

Tree before deleting key: 3 2 4 1 8 6 9 5 7
Tree after deleting key: 3 2 4 1 8 6 9 7

结论

如果您在本教程中有任何疑问,请在评论区提出。

更新于:2021年1月27日

5000+ 次浏览

开启您的职业生涯

完成课程获得认证

开始学习
广告
© . All rights reserved.