《数据结构与算法分析》学习笔记（五）——树ADT

一、二叉树

1、定义

         二叉树是一棵树，其中每个节点都不能多于2个儿子。

2、实现

typedef struct TreeNode *PtrToNode;

typedef PtrToNode Tree;

typedef char ElementType;





struct TreeNode

{

    ElementType Element;

    Tree Left;

    Tree Right;

};

3、通过后序表达式构造一个表达式树

void bianli(Tree t)

{

    if (t)

    {

        bianli(t->Left);

        cout << t->Element << " ";

        bianli(t->Right);

    }

}



int main()

{



    char c;

    stack<Tree> treeStack;

    

    while (1)

    {

        cout << "Please enter a suffix expression!(the last must is ';')" << endl;

        cin >> c;

        if (c == ';')

        {

            break;

        }

        else

        {

            if (c == '+' || c == '-' || c == '*' || c == '/')

            {

                auto t2 = treeStack.top();

                treeStack.pop();

                auto t1 = treeStack.top();

                treeStack.pop();



                PtrToNode temp2 = new(struct TreeNode);



                temp2->Element = c;

                temp2->Left = t1;

                temp2->Right = t2;



                treeStack.push(temp2);



            }

            else

            {

                PtrToNode temp;

                temp = new(struct TreeNode);

                temp->Element = c;

                temp->Left = temp->Right = nullptr;

                treeStack.push(temp);

            }

        }

    }



    auto t = treeStack.top();

    bianli(t);

    

    return 0;

}

二、查找树ADT

1、定义

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

2、实现

#ifndef _Tree_H

#define _Tree_H



//结点结构的声明~

struct TreeNode;



typedef struct TreeNode *Position;

typedef struct TreeNode *SearchTree;



typedef int ElementType;//关键字的类型

//一些方法的声明

SearchTree MakeEmpty(SearchTree T);

Position Find(SearchTree, ElementType X);

Position FindMin(SearchTree T);

Position FindMxa(SearchTree T);

SearchTree Insert(ElementType X, SearchTree T);

SearchTree Delete(ElementType X, SearchTree T);

ElementType Retrieve(Position P);





#endif // !_Tree_H

struct TreeNode           //结点结构实现

{

    ElementType Element;

    SearchTree Left;

    SearchTree Right;



};

3、相关方法的实现

（1）清空~

          清空记得要使用后序遍历的方法，因为后序遍历才能够才能够保证把所有子树清完。

SearchTree MakeEmpty(SearchTree T)

{

    if (T)

    {

        MakeEmpty(T->Left);

        MakeEmpty(T->Right);

        delete(T);

    }

    return nullptr;

}

（2）查找

          就是比结点小的，就递归去找左子树，大的去找右子树

Position Find(SearchTree T, ElementType X)

{

    if (T)

    {

        if (T->Element == X)

        {

            return T;

        }

        else if (T->Element>X)

        {

            return Find(T->Left, X);

        }

        else

        {

            return Find(T->Right, X);

        }

    }

    

        return nullptr;



}

（3）找到最小的

           一种方法就是不断的递归去找它的左子树，直到最后一个结点。

Position FindMin(SearchTree T)

{

    if (T)

    {

        if (T->Left == nullptr)

        {

            return T;

        }

        else

        {

            return FindMin(T);

        }

    }

    else

    {

        return nullptr;

    }

}

（3）找到最大的

          当然，这种简单的递归，可以用一个for循环就可以搞定了。

Position FindMax(SearchTree T)

{

    if (T != nullptr)

    {

        while (T->Right != nullptr)

        {

            T = T->Right;

        }

    }

    return T;

}

（4）插入

//插入
SearchTree Insert(ElementType X, SearchTree T)
{
    if (T == nullptr)       //空树，就插入
    {
        T = new(struct TreeNode);
        if (T = nullptr)
        {
            cout << "Out of Space!" << endl;
        }
        else
        {
            T->Element = X;
            T->Left = T->Right = nullptr;
        }
    }
    else if (T->Element < X)
    {
        T->Left = Insert(X, T->Left);
    }
    else if (T->Element>X)            
    {
        T->Right = Insert(X, T->Right);
    }
    else                         //一样的话就说明已经有了
    {
        cout << "It has existed!" << endl;
    }

    return T;       //记得返回一下下
}

（5）删除

//删除
SearchTree Delete(ElementType X, SearchTree T)
{
    if (T == nullptr)        //找到空树，就停下来
    {
        cout << "Element not found!" << endl;
    }
    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)        //子树都存在的时候，用右子树中最小的来替代它。
    {
        auto t = FindMin(T->Right);
        T->Element = t->Element;
        T->Right = Delete(T->Element, T->Right);
    }
    else                          //只有一个子树或者没有的话，就很简单，直接替代或者delete
    {
        auto t = T;
        if (T->Left == nullptr)
        {
            T = T->Right;
        }
        else if (T->Right == nullptr)
        {
            T = T->Left;
        }
        else
        {
            delete(t);
        }
    }   return T;
}