数据结构与算法分析——树学习

树

定义：一棵树由根（root）节点以及0到多个非空的子树组成，每颗子树的根都被来自root的一条有向边连接。

节点间的关系：有子节点B、C的节点A被称为B、C的父亲，节点B、C称为A的儿子，节点C是节点B的兄弟节点。

树叶：没有儿子的节点称为树叶。

路径：从节点N1到节点Nk的路径定义为N1、N2、N3……Nk的一个序列，1其中对于任意i(1<=i<k)都存在Ni是Ni+1的父亲节点。

路径的长：这条路径上的边的条数，从节点N1到节点Nk的路径的长为k-1。任意两节点间只存在一条路径。

节点的深度：从根节点到该节点的路径的长，根的深度为0。

节点的高：从该节点到一片树叶的最长路径。任意树叶的高为0。

树的深度：一棵树的深度等于最深的树叶的深度，这个深度即为树的高。

树的声明

typedef struct TreeNode *PtrToNode；

struct TreeNode{

    ElementType Element；

    TreeNode *FirstChild;

    TreeNode *NextSibling;

}

树的遍历

先序遍历：先处理该节点，再对该节点的所有子节点进行处理；

中序遍历：先处理该节点的左节点，再处理该节点，最后处理该节点的右节点；

后序遍历：先处理该节点的所有子节点，再处理该节点。

二叉树（binary tree）

定义：每个节点都不能有多余两个的子节点。

深度：平均二叉树的平均深度为O(根号N)，二叉查找树的平均深度为O(logN)。

实现：

typedef struct TreeNode *PtrToNode;

typedef struct PtrToNode Tree;

struct TreeNode{

    ElementType Element;

    Tree Left;

    Tree Right;

}

表达式树（expression tree）

树叶是操作数（operand），其他节点为操作符（operator）。

例子：表达式：(a+(b*c))+(((d*e)+f)*g)

中序遍历输出：a+b*c+(d*e+f)*g

先序遍历输出：++a+bc*+*defg

后序遍历输出：abc*+de*f+g*+

表达式树的构造：可用栈

Tree create（Expression e）{

    stack s;

   Create(s,e);

    for each expression element

        Tree T;

        Create(T, element);

        if(element != operator)

            s->arr[++s->top] = T;

        else

            T->Right = s->arr[s->top--];

            T->Left = s->arr[s->top--];

            s->arr[++s->top] = T;

    return T;

}

查找树

二叉查找树

性质：对于树中的每个节点X，它的左子树中所有关键字值小于X的关键字值，它的右子树中的所有关键字值大于X的关键字值。

平均深度：O(logN)

函数：MakeEmpty、Find、FindMin、FindMax、Insert、Delete

SearchTree MakeEmpt（SearchTree T）{//递归实现建立一个空树

    if(T != NULL){

        MakeEmpty(T->Left);

        MakeEmpty(T->Right);

        free(T);

    }

    return NULL;

}

SearchTree MakeEmpty(SearchTree T){//建立一个单节点树

    T = malloc(sizeof(SearchTree));

    T->Left = NULL;

    T->Right = NULL;

    return T;

}

Position Find(ElementType X, SearchTree T){

    if(T == NULL)

        return NULL;

    if(X > T->Element)

      return  Find(X, T->Right);

    else if(X < T->Element)

        return Find(X, T->Left);

    else

        return T;

}

Position FindMin(SearchTree T){//FindMax从右子树搜索

    if( T == NULL)

        return NULL;

    if(T->Left != NULL)

        return FindMin(T->Left);

    else

        return T;

}

SearchTree Insert(ElementType X,SearchTree T){

    if(T == NULL){

        MakeEmpty(T);

        T->Element = X;

        return T;

    } else  if( X > T->Element)

        return Insert(X, T->Right);

    else if(X < T->Element)

        return Insert(X, T->Left);

    return T;

}

SearchTree Delete(ElementType X, SearchTree T){

    if(T == NULL)

        return NULL;

    else if(X < T->Element)

        T->Left = Delete(X, T->Left);

    else if(X > T->Element)

        T->Right = Delete(X, T->Right);

    else if( T->Left && T->Right)

        int i = rand(0,1);//平衡树的深度

        if(i == 0)

            TmpCell = FindMax(T->Left);

            T->Element = TmpCell->Element;

            T->Left = Delete(T->Element, T->Left);

        else

            TmpCell = FindMin(T->Right);

            T->Element = TmpCell->Element;

            T->Right = Delete(T->Element, T->Right);

    else

        TmpCell = T;

        if(T->Right == NULL)

            T = T->Left;

        else if(T->Left == NULL)

             T = T->Right;

        free(TmpCell);

    return T;

}