樹的孩子兄弟表示法

typedef struct DataType 
{

}DataType;
typedef struct Node 
{
    DataType element;
    struct Node * pFirstChild;
    struct Node * pNextSibling;
}*Tree,*Queue;

 

樹的先序遞歸遍歷：

void TraverseTree(Tree p)
{
    if(p==NULL) return;
    cout<<p->element<<endl;
    TraverseTree(p->pFirstChild);
    TraverseTree(p->pNextSibling);
}

上面輸出結果：訪問順序 A B E C F I G H J K L D

數的先序非遞歸遍歷：

 

void TraverseTree(Tree p)
{
    if(p==NULL) return;
    cout<<p->element<<endl;
    TraverseTree(p->pNextSibling);
    TraverseTree(p->pFirstChild);
}

上面輸出結果：A B C D F G H J K L I E

void AddTree(Tree p,DataType parent,DataType element)
{
    Queue queue;
    BOOL flag=FALSE;
    Tree tree;
    while (p||!Empty(queue)&&!flag)
    {
        while (p)
        {
            EnQueue(queue,p);
            p=p->pNextSibling;
        }
        if (!Empty(queue))
        {
            p=Dequeue(queue);
            if (p->element==parent)
            {
                flag=TRUE;
                tree=p;
                break;
            }
        }
    }
    Tree temp1=tree->pFirstChild;
    Tree temp2=(Tree)malloc(sizeof(struct Node));
    temp2->element=element;
    temp2->pFirstChild=NULL;
    temp2->pNextSibling=temp1;
    tree->pFirstChild=temp2;
    while (!Empty(queue))
    {
        DeQueue(queue);
    }
}

//刪除節點：

（1）找到父節點

（2）修改父節點及兄弟節點的指向

（3）析構該節點所對應的樹

析構一棵樹：

（1）層次遍歷樹的節點，出隊的時候free，把訪問變成free，同時注意free之前保存其第一個孩子

//按層次遍歷
void TraverseLayer(Tree p)
{
    Queue queue;
    while (p||!empty(queue))
    {
        while (p)
        {
            EnQueue(queue,p);
            p=p->pNextSibling;
        }
        if(!empty(queue))
        {
            p=DeQueue(queue);
            cout<<p->element<<endl;
            p=p->pFirstChild;
        }
        else
        {
            return;
        }
    }
}

輸出結果 A B C D E F G H  I JK L

Tree FindParent(Tree tree,DataType element)
{
    Tree p=tree;
    BOOL flag=FALSE;
    Tree parent;
    Queue queue;
    while (p||!Empty(queue)&&!flag)
    {
        while (p)
        {
            EnQueue(queue,p);
            p=p->pNextSibling;
        }
        if (!EmptyQueue(queue))
        {
            p=DeQueue(queue);
            Tree temp=p->pFirstChild;
            while (temp)
            {
                if (temp->element==element)
                {
                    parent=p;
                    flag=true;
                    break;
                }
            }
            p=p->pFirstChild;
        }
    }
    while (!empty(queue))
    {
        Dequeue(queue);
    }
    return parent;
}
int  TreeDepth(Tree p)
{
    if (p==NULL)
    {
        return 0;
    }
    p=p->pFirstChild;
    int max=0;
    while (p)
    {
        int depth=TreeDepth(p);
        if (max<depth)
        {
            max=depth;
        }
        p=p->pNextSibling;
    }
    return max+1;
}