¡La eliminación del árbol binario es simple y fácil de entender! ! ! !

Comprensión del contenido
Referencia: https://blog.csdn.net/u013834525/article/details/80506126
Adición, eliminación, modificación y consulta del árbol binario

Todo lo demás es simple, pero es más problemático eliminarlo.

Hay tres casos a considerar
1. El caso sin nodo secundario
2. Hay 1 nodo secundario
3. Hay dos nodos secundarios
La razón principal es que hay dos nodos secundarios. Paso de código
a. Cuando el nodo eliminado es el principal nodo
======= ===== 1. Primero use una variable para almacenar temporalmente y atravesar hasta el nodo más a la izquierda en el lado derecho del nodo principal
============ 2. Mueva todo el lado izquierdo del nodo principal al lado izquierdo de la variable que acaba de buscar
-============ 3. Cambie el nodo principal al nodo inicial derecho del nodo principal original
b. Cuando el nodo eliminado no es el principal
============ 1. Primero determine si está a la izquierda o a la derecha del nodo principal
============= 2 .Atraviese el nodo que se va a eliminar hacia el extremo izquierdo a la derecha
============= 3. Mueva todo el lado izquierdo del nodo que se va a eliminar hacia el lado más izquierdo
del nodo que se va a atravesar Recién conectado al nodo de origen.

eliminar el nodo principal

después de eliminar eliminar

el medio

después de eliminar

el código

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