建立二叉树并输出每个字符所在的层数。如下图要求输出A在第一层 B,C在第二层 D,E在第三层

图片.png

代码实现如下：

#include<stdafx.h>
#include<stdio.h>
#include<stdlib.h>

typedef char ElemType;

typedef struct BiTNode {
    char data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
//创建一颗二叉树，约定用户遵照前序遍历的方式输入数据
void CreateBiTree(BiTree *T) {
    char c;
    scanf_s("%c", &c);
    if (' ' == c) 
    {
        *T = NULL;
    }
    else
    {
        *T = (BiTNode *)malloc(sizeof(BiTNode));
        (*T)->data = c;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}
//访问二叉树节点的具体操作，你想干嘛
void visit(ElemType elem, int level) {
    printf("%c 位于第%d层\n", elem, level);
}
//前序遍历二叉树
void PreOrderTraverse(BiTree T, int level) {
    if (T)
    {
        visit(T->data, level);
        PreOrderTraverse(T->lchild, level + 1);
        PreOrderTraverse(T->rchild, level + 1);
    }
}

int main() {
    int level = 1;
    BiTree T = NULL;
    CreateBiTree(&T);
    PreOrderTraverse(T, level);
    getchar();
    getchar();
    return 0;
}

线索二叉树

图片.png

-ltag为0时指向该节点的左孩子，为1时指向该节点的前驱
-rtag为0时指向该节点的右孩子，为1时指向该节点的后继

代码实现

#include<stdafx.h>
#include<stdio.h>
#include<stdlib.h>

typedef char ElemType;
typedef int PointerTag;
//线索存储标志位 
//link（0）:表示指向左右孩子的指针
//Thread(1): 表示指向前驱后继的线索
typedef enum {Link, Thread};
typedef struct BiThrNode {
    char data;
    struct BiThrNode *lchild, *rchild;
    PointerTag ltag;
    PointerTag rtag;
}BiThrNode, *BiThrTree;

//全局变量，始终指向刚刚访问过的节点
BiThrTree pre;

//创建一颗二叉树 约定用户遵照前序遍历的方式输入数据
void CreateBiThrTree(BiThrTree *T) {
    char c;
    scanf_s("%c", &c);
    if (' ' == c)
    {
        *T = NULL;
    }
    else
    {
        *T = (BiThrNode *)malloc(sizeof(BiThrNode));
        (*T)->data = c;
        (*T)->ltag = Link;
        (*T)->rtag = Link;

        CreateBiThrTree(&(*T)->lchild);
        CreateBiThrTree(&(*T)->rchild);
    }
}

void InThreading(BiThrTree T) {
    if (T)
    {
        InThreading(T->lchild); //递归左孩子线索化
        //节点处理
        if (!T->lchild)    //如果该节点没有左孩子，设置ltag为Thread, 并把lchild指向刚刚访问的节点
        {
            T->ltag = Thread;
            T->lchild = pre;
        }
        if (!pre->rchild)
        {
            pre->rtag = Thread;
            pre->rchild = T;
        }
        pre = T;

        InThreading(T->rchild); //递归右孩子线索化
    }
}
void InOrderThreading(BiThrTree *p, BiThrTree T) {
    *p = (BiThrTree)malloc(sizeof(BiThrNode));
    (*p)->ltag = Link;
    (*p)->rtag = Thread;
    (*p)->rchild = *p;
    if (!T) {
        (*p)->lchild = *p;
    }
    else
    {
        (*p)->lchild = T;
        pre = *p;
        InThreading(T);
        pre->rchild = *p;
        pre->rtag = Thread;
        (*p)->rchild = pre;
    }
}

void visit(char c) {
    printf("%c", c);
}

//中序遍历二叉树 非递归
void InOrderTraverse(BiThrTree T) {
    BiThrTree p;
    p = T->lchild;
    while (p != T)
    {
        while (p->ltag == Link)
        {
            p = p->lchild;
        }
        visit(p->data);
        while (p->rtag == Thread && p->rchild != T)
        {
            p = p->rchild;
            visit(p->data);
        }
        p = p->rchild;
    }
}
int main() {
    BiThrTree P, T = NULL;
    CreateBiThrTree(&T);
    InOrderThreading(&P, T);
    printf("中序遍历结果为：");
    InOrderTraverse(P);

    getchar();
    getchar();
    return 0;
}