数据结构与算法分析 学习笔记 （3）

树

---

#ifndef _Tree_H
struct TreeNode;
typedef struct TreeNode *Position;
typedef Struct TreeNode *SearchTree;

SearchTree MakeEmpty(Search T);
Position Find(ElemtntType X,SearchTree T);
Position FindMin(SearchTree T);
Position FindMax(SearchTree T);
SearchTree Insert(ElementType X,SearchTree T);
SearchTree Delete(ElementType X,SearchTree T);
ElementType Retrieve(Position P);

struct TreeNode
{
    ElementType Element;
    SearchTree Left;
    SearchTree Right;
};

//建立一个空二叉树

SearchTree MakeEmpty（SearchTree T）
{
    if（T！=Null）
    {
        MakeEmpty(T->left);
        MakeEmpty(T->Right);
        free(T);
    }
    return NULL;
}

//二叉树的查找
Position Find(ElementType X,SearchTree T);
{
    if(T==NULL)
        return NULL;
    if(X>T->Element)
        return Find(X,T->Left);
    else if(X<T->Element)
        return Find(X,T->Right);
        else return T;
}

//二叉查找树的FindMin递归实现
Position FindMin(SearchTree T)
{
    if(NULL==T)
        return NULL;
    if(NULL==T->Left)
        return T->Left;
    else
        return FindMin(T->Left);
}
//二叉查找树的FindMax的非递归实现

Position FindMax(SearchTree T)
{
    if(NULL!=T)
        while(NULL!=T->Right)
            T=T->Right;
    return T;
}
//插入元素到二叉查找树之中
SearchTree Insert(ElementType X,SearchTree T)
{
    if(NULL==T)
    {
        T=malloc(sizeof(Strunt TreeNode));
        if(NULL==T)
            FataErro("Out of Space! ");
        else
        {
            T->Element=X;
            T->Right=Null;
            T->Left=NULL;
        }
    }
    else if(X<T->Element)
            Insert(X,X->Left);
         else(X>T->Element)
            Insert(X,X->Right);
//if X==T->Element,X has been T's element.We will do nothing.
    return T;
}
//二叉查找树的删除，删除时有个节点转移的问题；
SearchTree Delete(ElementType X,SearchTree T)
{
    Position PtrTmp;
    if(NULL==T)
        Erro("Element is not found");
    else if(X<T->Element)//if smaller, go left
            Delete(X,T->Left);
            else if(X>T->Element)//if bigger go right
                Delete(X,T->Right);
                 else if(T->Riht&&T->Left)//Found it, the left and the right child trees both exist;
                        {
                            PtrTmp=FindMin(T->Right);//用右子树的最小的点替代被删除的元素
                            T->Element=PtrTmp->Element;
                            T->Right=Delete(T->Element,T->Right);//右子树为递归删除最小节点的改变后的节点
                        }
                        else//零个或者1个孩子的情况
                        {
                            PtrTmp=T;
                            if(NULL==T->Left)
                                T=T->Right;
                            else if(NULL=T->Right)
                                T=T->Left;
                                free(PtrTmp);
                        }
    return T;
}        

 普通二叉树的缺点是 容易使树的左子树或者右子树深度失衡，从而查找的时间复杂度退化，从而引申出“平衡二叉树”（AVL树）

---

平衡二叉树（AVL树）关键是旋转来使其平衡；

---

伸展树：它保证从空树开始任意连续M次对树的操作最多花费O(MlogN)时间；但是这种保证不排除任意一次操作花费O（N）时间的可能；它可以保证不存在坏的输入队列；

---

树的遍历；

顺序打印二叉树的中序；

void PrintTree(SearchTree T)
{
    if(NULL!=T)
        {
            PrintTree(T->Left);
            PrintElement(T->Element);
            PrintTree(T->Right);
        }
}

使用后序遍历计算树的高度

int Height(Tree T)
{
    if (NULL==T)
        return -1;
    else
        return 1+Max(Height(T->Left),Height(T->Right));
}

---

阶为M的B-树的定义：

　　1，树的根或者是一片树叶，或者其儿子在2和M之间；

　　2，除根外，所有非树叶节点的儿子树在¬M/2¬和M之间；

　　3, 所有的树叶都在相同的深度上；

 所有的数据都存储在树叶上；

4阶的B-树更流行的称呼是2-3-4树，而3阶的B-树叫做2-3树；

B-树的深度最多是¬log_¬m/2¬N¬

B-树在路径上的每个节点，执行O（logM）时间的工作量以确定选择哪个分支（使用折半查找），但是在Insert和Delete可能需要O（M）的工作量来调节点上的信息，对于每一个Insert和Delete，最坏的情形运行时间是

O(Mlog_MN)=O((M/logM)logN),对一次Find操作花费O(logN),经验指出：M=3或4运行时间最好，大于5之上没什么优势；

B-树实际运用于数据库系统，树被存储在硬盘而不是主存中，

---

在实践中，，所有平衡树方案的运行时间都不如简单二叉树查找树省时（差一个常数因子）但是可以接受，它防止轻易得到最坏情形的输入；；