树的双亲表示法(c语言实现) -A

简述说明

树结点: 数据域 & 双亲域 & id标识.
树结点的id标识就是树结点的存储下标.
修改数据域数据类型则需要修改部分代码使兼容.
树结点按层序序列存储
树结点从下标1开始存储, 即下标0不做存储.

CreateTree_P函数说明

输入字符串生成与其对应的树 (例如 A BC D EF GHI J ^ ^ ^ ^ ^)
A的孩子BC, 则 A BC
B的孩子D, 则 A BC D
C的孩子EF, 则 A BC D EF
D的孩子GHI, 则 A BC D EF GHI
E的孩子J, 则 A BC D EF GHI J
FGHIJ都没有孩子, 所以 A BC D EF GHI J ^ ^ ^ ^ ^

存储结构

c语言实现代码

main.c

#include 
#include 
#include "ParentTree.h"
#define STR_MAXSIZE 1024



void PrintMenu(void);
void ClearStdin(void);

void Init_Test(PTree *T);
void Create_Test(PTree *T);
void PrintTable_Test(const PTree *T);
void Clear_Test(PTree *T);
void Destroy_Test(PTree *T);
void Empty_Test(const PTree *T);
void Degree_Test(const PTree *T);
void Depth_Test(const PTree *T);
void Root_Test(const PTree *T);
void Value_Test(PTree *T);
void Order_Data_Test(const PTree *T);
void Assign_Data_Test(PTree *T);
void Assign_Id_Test(PTree *T);
void ChildValue_Data_Test(PTree *T);
void ChildValue_Id_Test(PTree *T);
void Sibling_Data_Test(PTree *T);
void Sibling_Id_Test(PTree *T);
void ChildCount_Data_Test(const PTree *T);
void ChildCount_Id_Test(const PTree *T);
void ChildSeat_Data_Test(PTree *T);
void ChildSeat_Id_Test(PTree *T);
void InsertChild_Data_Test(PTree *T);
void InsertChild_Id_Test(PTree *T);
void InsertTree_Data_Test(PTree *T);
void InsertTree_Id_Test(PTree *T);
void DeleteTree_Data_Test(PTree *T);
void DeleteTree_Id_Test(PTree *T);



void PrintMenu(void) {
    system("cls");
    puts("0. Exit n");
    puts("1. InitTree n");
    puts("2. CreateTree n");
    puts("3. PrintTreeTable n");
    puts("4. ClearTree n");
    puts("5. DestroyTree n");
    puts("6. EmptyTree n");
    puts("7. TreeDegree n");
    puts("8. TreeDepth n");
    puts("9. Root n");
    puts("10. Value n");
    puts("11. Order_Data n");
    puts("12. Assign_Data n");
    puts("13. Assign_Id n");
    puts("14. ChildValue_Data n");
    puts("15. ChildValue_Id n");
    puts("16. Sibling_Data n");
    puts("17. Sibling_Id n");
    puts("18. ChildCount_Data n");
    puts("19. ChildCount_Id n");
    puts("20. ChildSeat_Data n");
    puts("21. ChildSeat_Id n");
    puts("22. InsertChild_Data n");
    puts("23. InsertChild_Id n");
    puts("24. InsertTree_Data n");
    puts("25. InsertTree_Id n");
    puts("26. DeleteTree_Data n");
    puts("27. DeleteTree_Id n");
    printf("Input: ");
}

void ClearStdin(void) {
    char ch;
    while(ch=getchar(), ch!='n');
}



void Init_Test(PTree *T) {
    system("cls");

    Size_T n;
    printf("Input n: ");
    scanf("%u", &n);
    ClearStdin();

    if(InitTree_P(T, n))
        puts("Error. ");
    else
        puts("Ok. ");

    system("pause");
}

void Create_Test(PTree *T) {
    system("cls");

    TElemType_P ch, str[STR_MAXSIZE];
    printf("Input str: ");
    for(Size_T i=0; inodes[%u] = %c n", k, p->data);
    else
        printf("T->nodes[%u] = NULL n", k);
    
    system("pause");
}

void Order_Data_Test(const PTree *T) {
    system("cls");

    TElemType_P ch;
    printf("Input ch: ");
    ch = getchar();
    ClearStdin();
    printf("T->nodes[%u] = %c n", Order_Data_P(T, ch), ch);

    system("pause");
}

void Assign_Data_Test(PTree *T) {
    system("cls");

    TElemType_P ch, value;
    printf("Input ch & value: ");
    scanf("%c %c", &ch, &value);
    ClearStdin();

    if(Assign_Data_P(T, ch, value))
        puts("Error. ");
    else
        puts("Ok. ");

    system("pause");
}

void Assign_Id_Test(PTree *T) {
    system("cls");

    Id_P id;
    TElemType_P value;
    printf("Input id & value: ");
    scanf("%u %c", &id, &value);
    ClearStdin();

    if(Assign_Id_P(T, id, value))
        puts("Error. ");
    else
        puts("Ok. ");

    system("pause");
}

void ChildValue_Data_Test(PTree *T) {
    system("cls");

    PTNode *p;
    Size_T k;
    TElemType_P ch;
    printf("Input ch & k: ");
    scanf("%c %u", &ch, &k);
    ClearStdin();

    if(p = ChildValue_Data_P(T, ch, k))
        printf("The data is %c. n", p->data);
    else
        puts("The data is NULL. ");

    system("pause");
}

void ChildValue_Id_Test(PTree *T) {
    system("cls");

    PTNode *p;
    Id_P id;
    Size_T k;
    printf("Input id & k: ");
    scanf("%u %u", &id, &k);
    ClearStdin();

    if(p = ChildValue_Id_P(T, id, k))
        printf("The data is %c. n", p->data);
    else
        puts("The data is NULL. ");

    system("pause");
}

void Sibling_Data_Test(PTree *T) {
    system("cls");

    PTNode *p;
    TElemType_P ch;
    char mark;
    printf("Input ch & mark: ");
    scanf("%c %c", &ch, &mark);
    ClearStdin();
    p = Sibling_Data_P(T, ch, mark);
    
    switch(mark) {
        case LEFTSIB:
            if(p)
                printf("The leftsib of %c is %c. n", ch, p->data);
            else
                printf("The leftsib of %c is NULL. n", ch);
            break;
        case RIGHTSIB:
            if(p)
                printf("The rightsib of %c is %c. n", ch, p->data);
            else
                printf("The rightsib of %c is NULL. n", ch);
    }

    system("pause");
}

void Sibling_Id_Test(PTree *T) {
    system("cls");

    PTNode *p;
    Id_P id;
    char mark;
    printf("Input id & mark: ");
    scanf("%u %c", &id, &mark);
    ClearStdin();
    p = Sibling_Id_P(T, id, mark);

    switch(mark) {
        case LEFTSIB:
            if(p)
                printf("The leftsib of %u is %c. n", id, p->data);
            else
                printf("The leftsib of %u is NULL. n", id);
            break;
        case RIGHTSIB:
            if(p)
                printf("The rightsib of %u is %c. n", id, p->data);
            else
                printf("The rightsib of %u is NULL. n", id);
    }

    system("pause");
}

void ChildCount_Data_Test(const PTree *T) {
    system("cls");

    TElemType_P ch;
    printf("Input ch: ");
    ch = getchar();
    ClearStdin();
    printf("The count of %c'Child is %u. n", ch, ChildCount_Data_P(T, ch));

    system("pause");
}

void ChildCount_Id_Test(const PTree *T) {
    system("cls");

    Id_P id;
    printf("Input id: ");
    scanf("%u", &id);
    ClearStdin();
    printf("The count of %u'Child is %u. n", id, ChildCount_Id_P(T, id));

    system("pause");
}

void ChildSeat_Data_Test(PTree *T) {
    system("cls");

    TElemType_P ch;
    Size_T k;
    printf("Input ch & k: ");
    scanf("%c %u", &ch, &k);
    ClearStdin();
    printf("The position of %c'Child is %u. n", ch, ChildSeat_Data_P(T, ch, k));

    system("pause");
}

void ChildSeat_Id_Test(PTree *T) {
    system("cls");

    Id_P id;
    Size_T k;
    printf("Input id & k: ");
    scanf("%u %u", &id, &k);
    ClearStdin();
    printf("The position of %u'Child is %u. n", id, ChildSeat_Id_P(T, id, k));

    system("pause");
}

void InsertChild_Data_Test(PTree *T) {
    system("cls");

    Size_T k;
    TElemType_P a, b;
    printf("Input a & b & k: ");
    scanf("%c %c %u", &a, &b, &k);
    ClearStdin();
    
    if(InsertChild_Data_P(T, a, b, k))
        puts("Ok. ");
    else
        puts("Error. ");

    system("pause");
}

void InsertChild_Id_Test(PTree *T) {
    system("cls");

    Id_P id;
    Size_T k;
    TElemType_P ch;
    printf("Input id & ch & k: ");
    scanf("%u %c %u", &id, &ch, &k);
    ClearStdin();

    if(InsertChild_Id_P(T, id, ch, k))
        puts("Ok. ");
    else
        puts("Error. ");

    system("pause");
}

void InsertTree_Data_Test(PTree *T) {
    system("cls");

    PTree t;
    Size_T k;
    TElemType_P ch;

    InitTree_P(&t, 100);
    Create_Test(&t);

    printf("Input ch & k: ");
    scanf("%c %u", &ch, &k);
    ClearStdin();

    if(InsertTree_Data_P(T, ch, k, &t))
        puts("Error. ");
    else
        puts("Ok. ");

    DestroyTree_P(&t);
    system("pause");
}

void InsertTree_Id_Test(PTree *T) {
    system("cls");

    PTree t;
    Id_P id;
    Size_T k;

    InitTree_P(&t, 100);
    Create_Test(&t);

    printf("Input id & k: ");
    scanf("%u %u", &id, &k);
    ClearStdin();

    if(InsertTree_Id_P(T, id, k, &t))
        puts("Error. ");
    else
        puts("Ok. ");

    DestroyTree_P(&t);
    system("pause");
}

void DeleteTree_Data_Test(PTree *T) {
    system("cls");

    TElemType_P ch;
    Size_T k;

    printf("Input ch & k: ");
    scanf("%c %u", &ch, &k);
    ClearStdin();

    if(DeleteTree_Data_P(T, ch, k))
        puts("Error. ");
    else
        puts("Ok. ");

    system("pause");
}

void DeleteTree_Id_Test(PTree *T) {
    system("cls");

    Id_P id;
    printf("Input id: ");
    scanf("%u", &id);
    ClearStdin();

    if(DeleteTree_Id_P(T, id))
        puts("Error. ");
    else
        puts("Ok. ");

    system("pause");
}



int main(void) {
    PTree T;
    int choice;

    while(1) {
        choice = -1;
        PrintMenu();
        scanf("%d", &choice);
        ClearStdin();

        if(!choice) break;
        switch(choice) {
            case 1: Init_Test(&T); break;
            case 2: Create_Test(&T); break;
            case 3: PrintTable_Test(&T); break;
            case 4: Clear_Test(&T); break;
            case 5: Destroy_Test(&T); break;
            case 6: Empty_Test(&T); break;
            case 7: Degree_Test(&T); break;
            case 8: Depth_Test(&T); break;
            case 9: Root_Test(&T); break;
            case 10: Value_Test(&T); break;
            case 11: Order_Data_Test(&T); break;
            case 12: Assign_Data_Test(&T); break;
            case 13: Assign_Id_Test(&T); break;
            case 14: ChildValue_Data_Test(&T); break;
            case 15: ChildValue_Id_Test(&T); break;
            case 16: Sibling_Data_Test(&T); break;
            case 17: Sibling_Id_Test(&T); break;
            case 18: ChildCount_Data_Test(&T); break;
            case 19: ChildCount_Id_Test(&T); break;
            case 20: ChildSeat_Data_Test(&T); break;
            case 21: ChildSeat_Id_Test(&T); break;
            case 22: InsertChild_Data_Test(&T); break;
            case 23: InsertChild_Id_Test(&T); break;
            case 24: InsertTree_Data_Test(&T); break;
            case 25: InsertTree_Id_Test(&T); break;
            case 26: DeleteTree_Data_Test(&T); break;
            case 27: DeleteTree_Id_Test(&T); break;
        }
    }

    Destroy_Test(&T);
    puts("nOk n");
    return 0;
}

ParentTree.c

#include 
#include 
#include "ParentTree.h"

Status InitTree_P(PTree *T, const Size_T N) {
    if(T && N) {
        T->nodes = (PTNode *)malloc(sizeof(PTNode) * (N+1));
        if(!T->nodes) return ERROR;
        T->len = 1;
        T->maxsize = N+1;
        return OK;
    }
    return ERROR;
}

Status CreateTree_P(PTree *T, const char *str) {
    
    
    if(!T || !str)
        return ERROR;

    Size_T len=0, useful=0;
        Size_T count=1, parent=0;
        while(str[len]) {
            if(str[len]!=' ' && str[len]!='^')
                useful++;
            len++;
        }
        
        if(!useful || (*T).maxsize<=useful)
            return ERROR;
            
        for(Size_T i=0; i count)
                return ERROR;
            if(str[i]!=' ' && str[i]!='^') {
                while(inodes[count].data = str[i];
                        T->nodes[count].parent = parent;
                        T->nodes[count].id = count;
                        count++;
                        i++;
                    }else return ERROR;
                    
                parent++;
            }
        }

        if(parent == count) {
            T->len = count;
            return OK;
        }else return ERROR;
}

void PrintTreeTable_P(const PTree *T) {
    if(T) {
        printf("maxsize: %u t length: %u n", T->maxsize, T->len);
        printf("%s t %s t %s n", "id", "parent", "data");
        for(Size_T i=1; i<(*T).len; i++) {
            puts("------------------------------ ");
            printf("%u t %u tt %c n", T->nodes[i].id, T->nodes[i].parent, T->nodes[i].data);
        }
    }
}

void ClearTree_P(PTree *T) {
    if(T) {
        T->len = 1;
    }
}

void DestroyTree_P(PTree *T) {
    if(T) {
        free(T->nodes);
        T->nodes = NULL;
        T->maxsize = 0;
        T->len = 0;
    }
}

Bool TreeEmpty_P(const PTree *T) {
    return (T && T->len>1 ? FALSE : TRUE );
}

Size_T TreeDegree_P(const PTree *T) {
    Size_T max = 0;

    if(T) {
        Size_T count=0, parent=0;

        for(Size_T i=1; i<(*T).len; i++) {
            if(T->nodes[i].parent != parent) {
                count = 1;
                parent = T->nodes[i].parent;
            }else count++;
            max = (maxlen-1;

        while(k) {
            level++;
            k = T->nodes[k].parent;
        }
    }

    return level;
}

TElemType_P Root_P(const PTree *T) {
    return (T && (*T).len>1 ? T->nodes[1].data : '' );
}

PTNode* Value_P(PTree *T, const Size_T k) {
    if(T && (*T).len>1 && k<(*T).len)
        return (k ? T->nodes+k : T->nodes+(*T).len-1 );
    else
        return NULL;
}

Size_T Order_Data_P(const PTree *T, const TElemType_P e) {
    Size_T index = 0;

    if(T) {
        for(Size_T i=1; i<(*T).len; i++)
            if(T->nodes[i].data == e) {
                index = i;
                break;
            }
    }

    return index;
}

Status Assign_Data_P(PTree *T, const TElemType_P e, const TElemType_P value) {
    if(T) {
        for(Size_T i=1; i<(*T).len; i++)
            if(T->nodes[i].data == e) {
                T->nodes[i].data = value;
                return OK;
            }
    }
    return ERROR;
}

Status Assign_Id_P(PTree *T, const Id_P id, const TElemType_P value) {
    if(T && id && id<(*T).len) {
        T->nodes[id].data = value;
        return OK;
    }
    return ERROR;
}

PTNode* ChildValue_Data_P(PTree *T, const TElemType_P e, const Size_T order) {
    PTNode *p = NULL;

    if(T) {
        Size_T count = 1;
        
        for(Size_T i=2; i<(*T).len; i++) {
            Size_T parent = T->nodes[i].parent;

            if(T->nodes[parent].data == e) {
                Bool flag = (i+1<(*T).len && parent==T->nodes[i+1].parent);
                if((count==order) || (!order && !flag)) {
                    p = T->nodes+i;
                    break;
                }
                count = (flag ? count+1 : 1 );
            }
        }
    }

    return p;
}

PTNode* ChildValue_Id_P(PTree *T, const Id_P id, const Size_T order) {
    PTNode *p = NULL;

    if(T && id) {
        Size_T count = 1;

        for(Size_T i=id+1; i<(*T).len; i++) {
            Size_T parent = T->nodes[i].parent;

            if(parent == id) {
                
                Bool flag = (i+2>(*T).len || parent!=T->nodes[i+1].parent);
                if((order==count) || (!order && flag)) {
                    p = T->nodes+i;
                    break;
                }
                count++;
            }else if(parent > id) break;
        }
    }

    return p;
}

PTNode* Sibling_Data_P(PTree *T, const TElemType_P e, const char mark) {
    if(mark!=LEFTSIB && mark!=RIGHTSIB) return NULL;

    if(T) {
        for(Size_T i=2; i<(*T).len; i++)
            if(T->nodes[i].data == e)
                switch(mark) {
                    case LEFTSIB:
                        if(T->nodes[i-1].parent == T->nodes[i].parent)
                            return T->nodes+i-1;
                        break;
                    case RIGHTSIB:
                        if(i+1<(*T).len && T->nodes[i].parent==T->nodes[i+1].parent)
                            return T->nodes+i+1;
                }
    }

    return NULL;
}

PTNode* Sibling_Id_P(PTree *T, const Id_P id, const char mark) {
    PTNode *p = NULL;

    if(T && id>1 && id<(*T).len)
        switch(mark) {
            case LEFTSIB:
                if(T->nodes[id-1].parent == T->nodes[id].parent)
                    p = T->nodes+id-1;
                break;
            case RIGHTSIB:
                if(id+1<(*T).len && T->nodes[id].parent==T->nodes[id+1].parent)
                    p = T->nodes+id+1;
        }

    return p;
}

Size_T ChildCount_Data_P(const PTree *T, const TElemType_P e) {
    return ChildCount_Id_P(T, Order_Data_P(T, e));
}

Size_T ChildCount_Id_P(const PTree *T, const Id_P id) {
    Size_T count = 0;

    if(T && id) {
        for(Size_T i=id+1; i<(*T).len; i++) {
            if(T->nodes[i].parent == id)
                count++;
            if(T->nodes[i].parent > id)
                break;
        }
    }

    return count;
}

Size_T ChildSeat_Data_P(PTree *T, const TElemType_P e, const Size_T k) {
    PTNode *p = ChildValue_Data_P(T, e, k);
    return (p ? p->id : 0 );
}

Size_T ChildSeat_Id_P(PTree *T, const Id_P id, const Size_T k) {
    PTNode *p = ChildValue_Id_P(T, id, k);
    return (p ? p->id : 0 );
}

Size_T InsertChild_Data_P(PTree *T, const TElemType_P p, const TElemType_P e, const Size_T k) {
    Size_T index=0;

    if(T && (*T).len<(*T).maxsize)
        for(Size_T i=1; i<(*T).len; i++)
            if(T->nodes[i].data == p)
                if(index = InsertChild_Id_P(T, i, e, k))
                    break;

    return index;
}

Size_T InsertChild_Id_P(PTree *T, const Id_P id, const TElemType_P e, const Size_T k) {
    Size_T index=0, parent=id;

    if(T && id && id<(*T).len && (*T).len<(*T).maxsize) {
        index = (k<2 ? T->len : 0 );
        
        for(Size_T i=parent+1; i<(*T).len && i+k<(*T).len+2; i++)
            if(T->nodes[i].parent >= parent) {
                index = (k<2 ? i : 0 );

                if(T->nodes[i].parent == parent) {
                    if(!k) {
                        while(i<(*T).len && T->nodes[i].parent==parent)
                            i++;
                        index = i;
                    }else index = (T->nodes[i+k-1].parent==parent || T->nodes[i+k-2].parent==parent ? i+k-1 : 0 );
                }

                break;
            }
    }

    if(index) {
        for(Size_T i=(*T).len; i>index; i--) {
            T->nodes[i].data = T->nodes[i-1].data;
            T->nodes[i].parent = (T->nodes[i-1].parentnodes[i-1].parent : T->nodes[i-1].parent+1 );
            T->nodes[i].id = i;
        }
        T->nodes[index].data = e;
        T->nodes[index].parent = parent;
        T->nodes[index].id = index;
        T->len++;
    }
    
    return index;
}

Status InsertTree_Data_P(PTree *T, const TElemType_P p, const Size_T k, const PTree *t) {
    Status flag = ERROR;

    
    if(T && T->nodes && t && (*t).len>1 && (*T).len+(*t).len<(*T).maxsize+2) {
        Size_T *index = (Size_T *)malloc(sizeof(Size_T) * t->len);
        if(!index) return ERROR;
        index[1] = InsertChild_Data_P(T, p, t->nodes[1].data, k);

        if(index[1]) {
            flag = OK;
            for(Size_T i=2; i<(*t).len; i++)
                index[i] = InsertChild_Id_P(T, index[t->nodes[i].parent], t->nodes[i].data, 0);
        }

        free(index);
    }

    return flag;
}

Status InsertTree_Id_P(PTree *T, const Id_P id, const Size_T k, const PTree *t) {
    Status flag = ERROR;

    
    if(T && T->nodes && t && (*t).len>1 && (*T).len+(*t).len<(*T).maxsize+2) {
        Size_T *index = (Size_T *)malloc(sizeof(Size_T) * t->len);
        if(!index) return ERROR;
        index[1] = InsertChild_Id_P(T, id, t->nodes[1].data, k);

        if(index[1]) {
            flag = OK;
            for(Size_T i=2; i<(*t).len; i++)
                index[i] = InsertChild_Id_P(T, index[t->nodes[i].parent], t->nodes[i].data, 0);
        }

        free(index);
    }

    return flag;
}

Status DeleteTree_Data_P(PTree *T, const TElemType_P p, const Size_T k) {
    return DeleteTree_Id_P(T, ChildSeat_Data_P(T, p, k));
}

Status DeleteTree_Id_P(PTree *T, const Size_T k) {
    if(TreeEmpty_P(T) || !k || k>=(*T).len)
        return ERROR;

    Size_T count = 1;
    Size_T *index = (Size_T *)malloc(sizeof(Size_T) * T->len);
    if(!index) return ERROR;
    index[0] = k;

    for(Size_T i=k+1; i<(*T).len; i++)
        if(T->nodes[i].parent >= k)
            for(Size_T j=0; jnodes[i].parent == index[j]) {
                    index[count] = i;
                    count++;
                    break;
                }


    Size_T len=k, step=0, m=0;
    Size_T *del = (Size_T *)malloc(sizeof(Size_T) * count);
    if(!del) {
        free(index);
        return ERROR;
    }

    for(Size_T i=k; i<(*T).len; i++) {
        Bool flag = TRUE;

        for(Size_T j=m; jnodes[i].parent>del[step])
                step++;
            T->nodes[len].data = T->nodes[i].data;
            T->nodes[len].parent = T->nodes[i].parent-step;
            T->nodes[len].id = len;
            len++;
        }
    }

    T->len = len;
    free(del);
    free(index);
    return OK;
}

ParentTree.h

#ifndef PARENTTREE_H_INCLUDE
#define PARENTTREE_H_INCLUDE


typedef unsigned int Size_T;
typedef char Status;    //自定义状态型
typedef char Bool;      //自定义布尔型
#define TRUE 1      //真
#define FALSE 0     //假
#define OK 0        //正常
#define ERROR -1    //异常



#define LEFTSIB 'L'     //左兄弟
#define RIGHTSIB 'R'    //右兄弟

typedef char TElemType_P;   //树的自定义data类型
typedef Size_T Id_P;        //树的自定义id类型


typedef struct {
    TElemType_P data;   //数据域
    Size_T parent;      //双亲域
    Id_P id;            //id标识
} PTNode;


typedef struct {
    PTNode *nodes;      //结点域
    Size_T len;         //结点数
    Size_T maxsize;     //最大结点数
} PTree;





Status InitTree_P(PTree *T, const Size_T N);


Status CreateTree_P(PTree *T, const char *str);


void PrintTreeTable_P(const PTree *T);


void ClearTree_P(PTree *T);


void DestroyTree_P(PTree *T);


Bool TreeEmpty_P(const PTree *T);


Size_T TreeDegree_P(const PTree *T);


Size_T TreeDepth_P(const PTree *T);


TElemType_P Root_P(const PTree *T);


PTNode* Value_P(PTree *T, const Size_T k);


Size_T Order_Data_P(const PTree *T, const TElemType_P e);


Status Assign_Data_P(PTree *T, const TElemType_P e, const TElemType_P value);


Status Assign_Id_P(PTree *T, const Id_P id, const TElemType_P value);


PTNode* ChildValue_Data_P(PTree *T, const TElemType_P e, const Size_T order);


PTNode* ChildValue_Id_P(PTree *T, const Id_P id, const Size_T order);


PTNode* Sibling_Data_P(PTree *T, const TElemType_P e, const char mark);


PTNode* Sibling_Id_P(PTree *T, const Id_P id, const char mark);


Size_T ChildCount_Data_P(const PTree *T, const TElemType_P e);


Size_T ChildCount_Id_P(const PTree *T, const Id_P id);


Size_T ChildSeat_Data_P(PTree *T, const TElemType_P e, const Size_T k);


Size_T ChildSeat_Id_P(PTree *T, const Id_P id, const Size_T k);


Size_T InsertChild_Data_P(PTree *T, const TElemType_P p, const TElemType_P e, const Size_T k);


Size_T InsertChild_Id_P(PTree *T, const Id_P id, const TElemType_P e, const Size_T k);


Status InsertTree_Data_P(PTree *T, const TElemType_P p, const Size_T k, const PTree *t);


Status InsertTree_Id_P(PTree *T, const Id_P id, const Size_T k, const PTree *t);


Status DeleteTree_Data_P(PTree *T, const TElemType_P p, const Size_T k);


Status DeleteTree_Id_P(PTree *T, const Size_T k);


#endif //PARENTTREE_H_INCLUDE

树的双亲表示法(c语言实现) -A

C/C++/C#相关栏目本月热门文章