数据结构 树的创建（线索化二叉树）

//二叉树的线索化
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//定义二叉树线索化节点
typedef struct _TreeNode{
    char data;
    char lefttag;//0表示没有线索化，1表示线索化---每次创建节点都会初始化 所以所有节点默认都是0
    char righttag;
    struct _TreeNode * leftchild;
    struct _TreeNode * rightchild;
}TreeNode, *TreeNodePointer;

//定义前驱节点
TreeNodePointer pre = NULL;

/*
线索二叉树的定义
普通二叉树只能找到结点的左右孩子信息，而该结点的直接前驱和直接后继只能在遍历过程中获得。
n个结点的二叉链表中含有n+1(2n-(n-1)=n+1)个空指针域。
利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前趋和后继结点的指针（这种附加的指针称为"线索"）。

备注：二叉树的遍历很复杂，销毁判断也会增加，暂时没看出任何优势所在，虽然花了我2天时间
线索化二叉树并不能通过头节点前驱，后继像链表一样顺序访问，因为原来的双亲节点的后继不是正确的  
如图，如果正常的链表 A结点的后继应该是H 结果这里是E   根本无法顺序访问    如果以后有所顿悟  再来修改



*/

//创建树
TreeNodePointer CreateTree(){
    //定义结构体对象
    TreeNodePointer t1 = NULL, t2 = NULL, t3 = NULL, t4 = NULL, t5 = NULL, t6 = NULL, t7 = NULL, t8 = NULL, t9 = NULL;
    t1 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t1 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t1, 0, sizeof(TreeNode));
    t2 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t2 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t2, 0, sizeof(TreeNode));
    t3 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t3 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t3, 0, sizeof(TreeNode));
    t4 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t4 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t4, 0, sizeof(TreeNode));
    t5 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t5 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t5, 0, sizeof(TreeNode));
    t6 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t6 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t6, 0, sizeof(TreeNode));
    t7 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t7 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t7, 0, sizeof(TreeNode));
    t8 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t8 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t8, 0, sizeof(TreeNode));
    t9 = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (t9 == NULL)
    {
        printf("分配内存失败！");
        return NULL;
    }
    //初始化数据
    memset(t9, 0, sizeof(TreeNode));
    //填充数据域
    t1->data = ‘A‘;
    t2->data = ‘B‘;
    t3->data = ‘C‘;
    t4->data = ‘D‘;
    t5->data = ‘E‘;
    t6->data = ‘F‘;
    t7->data = ‘G‘;
    t8->data = ‘H‘;
    t9->data = ‘I‘;

    //建立树之间的关系
    t1->leftchild = t2;
    t1->rightchild = t5;

    t2->leftchild = NULL;
    t2->rightchild = t3;

    t3->leftchild = t4;
    t3->rightchild = NULL;

    // t5是t4的左孩子
    t4->leftchild = NULL;
    t4->rightchild = NULL;

    //t5没有孩子节点
    t5->leftchild = NULL;
    t5->rightchild = t6;

    t6->leftchild = t7;
    t6->rightchild = NULL;

    t7->leftchild = t8;
    t7->rightchild = t9;

    t8->leftchild = NULL;
    t8->rightchild = NULL;

    t9->leftchild = NULL;
    t9->rightchild = NULL;

    return t1;

}

//销毁树
void Destroy(TreeNodePointer * root){
    if (root == NULL)
    {
        printf("传入参数不可以为空！\n");
        return;
    }
    TreeNodePointer temptree = *root;
    //遍历左子树
    if (temptree->lefttag == 0)
    {
        Destroy(&temptree->leftchild);
    }
    //遍历右子树
    if (temptree->righttag ==0)
    {
        Destroy(&temptree->rightchild);
    }
    //访问根节点
    if (temptree != NULL)
    {
        free(temptree);
        temptree = NULL;
        *root = NULL;
    }
}

//中序线索化树
void InorderThreading(TreeNodePointer root){
    //中序法线索化
    if (root != NULL)
    {
        //线索化左子树
        InorderThreading(root->leftchild);
        if (!root->leftchild)
        {
            //如果该结点的左子树为空，需要线索化
            root->lefttag = 1;
            //该节点的前驱指向前一个节点
            root->leftchild = pre;
        }
        //前驱节点的后继指向该结点
        if (!pre->rightchild)
        {
            //如果前驱结点的右子树为空，需要线索化
            pre->righttag = 1;
            pre->rightchild = root;
        }
        pre = root;
        //线索化右子树
        InorderThreading(root->rightchild);
    }
}

//遍历线索化二叉树
void ForeachTree(TreeNodePointer head){
    if (head==NULL)
    {
        printf("传入参数不可以为空！\n");
        return;
    }
    //获取根节点
    TreeNodePointer root = head->leftchild;
    while (root != head){
        //一直向左遍历  找到最左边的叶子
        while (root->lefttag == 0){
            root = root->leftchild;
        }
        printf("%c", root->data);
        //判断该节点的右孩子是不是线索 是线索  直接遍历  (遍历所有的右孩子是线索的结点)
        while (root->righttag == 1 && root->rightchild!=head)
        {
            root = root->rightchild;
            printf("%c", root->data);
        }
        //遍历该节点的右孩子
        root = root->rightchild;
    }
}

void Test(){
    //创建头结点
    TreeNodePointer head = (TreeNodePointer)malloc(sizeof(TreeNode));
    if (head == NULL)
    {
        printf("分配内存失败！\n");
        return;
    }
    //初始化
    memset(head, 0, sizeof(TreeNode));
    //定义树的根节点
    TreeNodePointer root = NULL;
    root = CreateTree();
    //根据线索化二叉树定义
    //----头结点的前驱指向根节点 线索化标识为0
    //----头节点的后继指向中序结果的最后一个元素 线索化标识为1
    head->leftchild = root;
    head->lefttag = 0;
    //为了防止头结点的后继指向中序的起点 先为头结点的后继赋值
    head->rightchild = head;
    head->righttag = 1;
    //此时前驱节点指向头结点
    pre = head;
    //线索化树
    InorderThreading(root);
    //此时pre指向的是中序遍历的最后一个节点 
    pre->rightchild = head;
    pre->righttag = 1;
    //头结点的右孩子指向中序遍历的最后一个节点
    head->rightchild = pre;
    //遍历线索化二叉树
    ForeachTree(head);
    //销毁树
    Destroy(&root);
    //释放头节点
    if (head!=NULL)
    {
        free(head);
        head = NULL;
    }
}

void main(){
    Test();
    system("pause");
}