La suppression d’arbre binaire est simple et facile à comprendre ! ! ! !

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;
}