```
BinTree Insert( BinTree BST, ElementType X){
if( !BST){ //If empty, generate and return a binary search tree for a node
BST = (BinTree)malloc(sizeof(struct TNode));
BST->Left = BST->Right = NULL;
BST->Data = X;
}else{
if( X > BST->Data)
BST->Right = Insert( BST->Right, X);//Return the root node of the subtree to BST->Right
else if( X < BST->Data)
BST->Left = Insert( BST->Left, X);//Return root node of subtree to BST->Left
}
return BST;
}
```

```
Position Find( BinTree BST, ElementType X ){
while( BST){
if( X > BST->Data) BST = BST->Right;//Find in the right subtree
else if( X < BST->Data) BST = BST->Left;//Find in the left subtree
else break;//Find succeeded, jump out of the loop, return to the current node
}
return BST;
}
```

```
Position FindMin( BinTree BST){
while( BST){
if( BST->Left) BST = BST->Left;
else break;//Find left until there is no left subtree, which is the minimum
}
return BST;
}
```

```
Position FindMax( BinTree BST){
while( BST){
if( BST->Right) BST = BST->Right;
else break;
}
return BST;
}
```

```
BinTree Delete( BinTree BST, ElementType X ){
Position temp;
if( !BST) printf("Not Found\n");//No element found to delete
else{
if( X > BST->Data) BST->Right = Delete( BST->Right, X);//Recursive deletion to right subtree
else if( X < BST->Data) BST->Left = Delete( BST->Left, X);//Recursive deletion to left subtree
else{//BST is the node to be deleted
if( BST->Left && BST->Right){//The case where BST has two subnodes
temp = FindMin( BST->Right);//Find the smallest node in the right subtree
BST->Data = temp->Data;//Change the value of BST to temp, that is, delete
BST->Right = Delete( BST->Right, BST->Data);//Delete the smallest node in the right subtree
}else{//Deleted node has only one node or no node
temp = BST;
if( !BST->Left) BST = BST->Right;//Only right node or no child node
else BST = BST->Left;//Only left node
free(temp);
}
}
}
return BST;
}
```

If you want to delete a leaf node, you can delete it directly, then modify the pointer of its parent node and leave it empty.

If the node you want to delete has only one child node, you need to change the pointer of its parent node to point to the child node you want to delete before deleting.That is to change the value of BST.(The BST returned is the child of the parent node)

When the deleted node has two nodes, you can select the largest node in the left subtree or the smallest node in the right subtree to replace the node to be deleted, which ensures that the replaced node is larger than the left subtree and smaller than the right subtree.It is known that this node has at most one child node, otherwise it does not satisfy the maximum or minimum conditions.The selected node can be deleted by deleting a node with only one child node.

In the delete operation, the return value of the function is the root node, BST->Right = Delete (BST->Right, X), that is, the node of the subtree after the delete operation is assigned to BST->Right, which does not affect the value of BST.When the last operation of recursion completes a step-by-step return, the nodes of the left and right subtrees are updated and the root node of the tree is returned.