Compréhension du contenu
Référence : https://blog.csdn.net/u013834525/article/details/80506126
Ajout, suppression, modification et requête d'arborescence binaire
Tout le reste est simple, mais il est plus compliqué à supprimer
Il y a trois cas à considérer
1. Le cas sans nœud enfant
2. Il y a 1 nœud enfant
3. Il y a deux nœuds enfants
La raison principale est qu'il y a deux nœuds enfants Étape de code
a. Lorsque le nœud supprimé est le nœud principal node
======= ===== 1. Utilisez d'abord une variable pour stocker temporairement et parcourir jusqu'au nœud le plus à gauche sur le côté droit du nœud principal
============2. Déplacez tout le côté gauche du nœud principal vers le côté gauche de la variable que vous venez de rechercher
-============ 3. Remplacez le nœud principal par le nœud de départ droit du nœud principal d'origine
b. Lorsque le nœud supprimé n'est pas la tête
============ 1. Déterminez d'abord s'il se trouve à gauche ou à droite du nœud parent
============= 2 . Traverser le nœud à supprimer tout à gauche sur la droite
============= 3. Déplacer tout le côté gauche du nœud à supprimer vers le côté le plus à gauche
du nœud à parcourir tout à l'heure connecté au nœud d'origine
supprimer le nœud principal
après la suppression supprimer
le milieu
après la suppression
le code
#include <stdio.h>
#include <stdlib.h>
typedef struct tree{
int data;
struct tree *left;
struct tree *right;
}Tree;
//查找节点并且同时记录节点的数值和父亲节点的数值
Tree * find_node;
Tree * parent_node;
void find_tree(Tree *root,int data){
if(root != NULL){
//如果找到节点则返回
if(root->data == data){
find_node=root;
parent_node=NULL;
return ;
}else if(root->data > data){//没找到则根据大小进行便利并且同时记录上节点的父亲节点
parent_node = root;
find_tree(root->left,data);
}else{
parent_node=root ;
find_tree(root->right,data);
}
}
}
//destory tree
void destory_tree(Tree *root){
if(root){
destory_tree(root->left);
destory_tree(root->right);
free(root);
}
}
//删除节点
void delete_tree(Tree **root,int data){
Tree *temp_node;
//找到要删除的节点以及父亲节点
find_tree(*root,data);
//分三种种情况讨论
//第一种情况也是最简单就是不存在子节点的节点删除
if(find_node->left==NULL&&find_node->right==NULL){
if(parent_node->left==find_node)
parent_node->left = NULL;
else
parent_node->right = NULL;
//进行2
free(find_node);
return ;
}
//第二种情况也就是中间节点,存在两边都是节点的情况
else if(find_node->right!=NULL&&find_node->right!=NULL){
//删除头节点
if(find_node == *root){
printf("the node is head\n");
temp_node = (*root)->right;
//便利到最左边
while(temp_node->left!=NULL){
temp_node=temp_node->left;
}
temp_node->left = (*root)->left;
*root=(*root)->right;
free(find_node);
return;
}
else{
//将这个节点插入到当前要删除节点右边的最左边
Tree *temp_node2 = find_node;
temp_node2=temp_node2->right;
while(temp_node2->left=NULL){
temp_node2=temp_node2->left;
}
temp_node2->left = find_node->left;
if(parent_node->left == find_node)
parent_node->left = find_node->right;
else
parent_node->right = find_node->right;
free(find_node);
return ;
}
}else{
if(parent_node->left=find_node){
if(find_node->left!=NULL)
parent_node->left = find_node->left;
else
parent_node->left = find_node->right;
}else{
if(find_node->left!=NULL)
parent_node->right = find_node->left;
else
parent_node->right = find_node->right;
}
free(find_node);
return ;
}
}
//前面 bianli
void pre_order(Tree *node){
if(node == NULL)
return ;
printf("%d\n", node->data);
pre_order(node->left);
pre_order(node->right);
}
void middle_order(Tree *node){
if(node == NULL)
return ;
pre_order(node->left);
printf("%d\n", node->data);
pre_order(node->right);
}
void back_order(Tree *node){
if(node == NULL)
return ;
pre_order(node->left);
pre_order(node->right);
printf("%d\n", node->data);
}
//初始化节嗲
struct tree *init_tree(int data ){
Tree *newnode;
newnode=(Tree *)malloc(sizeof(Tree));
newnode->data=data;
newnode->left=NULL;
newnode->right=NULL;
return newnode;
}
//插入节点
void inser_tree(Tree **root,Tree * newnode)
{
if(*root == NULL)
*root = newnode;
else if(newnode->data > (*root)-> data)
inser_tree(&((*root)->right),newnode);
else
inser_tree(&((*root)->left),newnode);
}
int main(int argc, char const *argv[])
{
Tree *root=NULL;
Tree *newnode=NULL;
int data;
int a[7]={5,3,1,4,8,6,9};
int i;
for(i=0;i<7;i++){
newnode=init_tree(a[i]);
inser_tree(&root,newnode);
}
data = 3;
delete_tree(&root,data);
pre_order(root);
//find_tree(root,data);
//printf("child Tree_node is:%d parent_node is %d\n",find_node->data,parent_node->data);
return 0;
}