树（c++实现）

#include <stdio.h>
#include <iostream>
using namespace std;
typedef struct TNode* Position;
typedef Position BinTree;
typedef  int ElementType;
struct TNode {
    ElementType Data;
    BinTree Left;//左子树
    BinTree Right;//右子树
};
bool IsEmpty(BinTree BT) {
    if(BT)return true;
    return NULL;
}
void Traversal(BinTree BT) {

}
BinTree CreatBinTree() {

}
//先序 根左右
void PreOrderTraversal(BinTree BT) {
    if (BT) {
        printf("%d", BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}
//void PreOrderTraversal(BinTree BT) {
//        BinTree T = BT;
//        Stack S = CreatStack(MaxSize);
//        while(T||!IsEmpty(S)){
//        while(T){
//      printf("%d",T->Data);
//        Push(S,T);
//        
//        T = T->Left;
// }
//        if(!IsEmpty(S)){
//        T = Pop(S);
//        
//        T = T->Right;
//
// }
// }
//}
//中序 左根右
void InOrderTraversal(BinTree BT) {
    if (BT) {
        InOrderTraversal(BT->Left);
        printf("%d", BT->Data);
        InOrderTraversal(BT->Right);
    }
}
//非递归
//void InOrderTraversal(BinTree BT) {
// BinTree T = BT;
// Stack S = CreatStack(MaxSize);创建并初始化堆栈
// while(T||!IsEmpty(S)){
// while(T){
//        Push(S,T);
//        T = T->Left;
// }
// if(!IsEmpty(S)){
//        T = Pop(S);
//        printf("%5d",T->Data);
//        T = T->Right;
// }    
// }
//}
//后序 左右根
void PostOrderTraversal(BinTree BT) {
    if (BT) {
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%d", BT->Data);
    }
}
//void PostOrderTraversal(BinTree BT) {}
    // stack *S;
    // BinTree *p,*q;
    // InitStack(S);
    // p = T;
    // q = NULL;
    // while(p||!EmptyStack(S){
    //        if(p!=q){
    //        while(p){
    //        push(S,p); p非空 压栈
    //        if(p->Left) p = p->Left;沿左指针下移
    //        else p = p->right;若左指针为空 则沿右指针下移
    // }
    // }
    // }
    // if(EmptyStack(S))break;
    // q = gettop(S);
    // if(q->right==p){
    //        p = pop(S);
    //        printf("%d",p->Data);
    // }
    //}
// 层次遍历 从上到下 从左到右
//void LevelOrderTraversal(BinTree BT){
//    queue Q;
//    BinTree T;
//    if (!BT)return;
//    Q = CreatQueue(Maxsize);
//    AddQ(Q, BT);
//    while (!IsEmptyQ(Q)) {
//        T = DeleteQ(Q);
//        printf("%d\n",T->Data);
//        if (T->Left)AddQ(Q, T->Left);
//        if (T->Right)AddQ(Q, T->Right);
//    }
//}
//输出二叉树中的叶子结点
void PrePrintf(BinTree BT) {
    if (BT) {
        if (!BT->Left && !BT->Right)printf("%d", BT->Data);
        PrePrintf(BT->Left);
        PrePrintf(BT->Right);
    }
}
//求二叉树的高度
int PostOrderGetHeight(BinTree BT) {
    int HL, HR, MaxH;
    if (BT) {
        HL = PostOrderGetHeight(BT->Left);
        HR = PostOrderGetHeight(BT->Right);
        MaxH = HL > HR ? HL : HR;
        return (MaxH + 1);
    }
    else return 0;
}
//二元运算表达式树及其遍历
//可以用中序和后序或前序确定一个树
//二叉树查找操作
//递归实现
BinTree Find(ElementType x, BinTree BST)
{
    if (!BST)return NULL;
    if (x > BST->Data)
        return Find(x, BST->Right);
    else if (x < BST->Data)
        return Find(x, BST->Left);
    else return BST;
}
//循环实现 执行效率高
BinTree Find(ElementType x, BinTree BST)
{
    while (BST) {
        if (x > BST->Data)BST = BST->Right;
        else if (x < BST->Data)BST = BST->Left;
        else return BST;
    }
    return NULL;
}
Position FindMin(BinTree BST)
{
    if (!BST)return NULL;
    else if (!BST->Left)
        return BST;
    else return FindMin(BST);
}
Position FinMax(BinTree BST) {
    if (BST)
        while (BST->Right) {
            BST = BST->Right;
        }
    return BST;

}
 BinTree Insert(BinTree BST,ElementType x )
{
     if (!BST) {//若原树为空，生成并返回一个结点的二叉搜索树
         BST = new TNode;
         BST->Data = x;
         BST->Left = BST->Right = NULL;
     }
     else {
         //开始找要插入元素的位置
         if (x < BST->Data)BST->Left = Insert(BST->Left, x);//递归插入左子树
         else if (x > BST->Data)BST->Right = Insert(BST->Right, x);//递归插入右子树
     }
     return BST;

}
 BinTree Delete(BinTree BST, ElementType x)
 {
     //算法思路：1.先找到被删除结点 定义临时变量tmp 将被删除结点的位置赋值给tmp
     // 2.判断被删除结点是否有两个子结点
     // a.若有两个子结点则找到右子树最小值或左子树最大值填充删除结点
     //b.若只有一个子结点则直接用其子结点填充被删除结点
     //3.释放临时变量
     Position tmp;
     if (!BST)cout << "要删除的元素未找到" << endl;
     else {
         if (x < BST->Data)BST->Left = Delete(BST->Left, x);// 递归删除左子树
         else if (x > BST->Data)BST->Right = Delete(BST->Right, x);//递归删除右子树
         else {
             if (BST->Left && BST->Right) {//被删除结点有左右两个子结点
                 tmp = FindMin(BST->Right);//找到右子树最小值填充删除结点
                 BST->Data = tmp->Data;
                 BST->Right = Delete(BST->Right, BST->Data);
             }
             else {//被删除结点只有一个子结点
                 tmp = BST;
                 if (!BST->Left)//有右孩子
                     BST = BST->Right;
                 else if (!BST->Right)//有左孩子
                     BST = BST->Left;
                 free(tmp);
             }

         }
     }
     return BST;
 }