数据结构(5.3_5)——二叉树的线索化

第一种寻找中序前驱方法

 中序线索化

本质上就是一次中序遍历，只不过需要在一边遍历一边处理结点线索化

代码：

//全局变量pre 指向当前访问结点的前驱
ThreadNode* pre = NULL;


struct ElemType {
    int value;
};

//线索二叉树结点
typedef struct ThreadNode {
    ElemType data;
    struct ThreadNode* lchild, * rchild;
    int ltag, rtag;//左、右线索标志
} ThreadNode, * ThreadTree;
//中序遍历二叉树，一边遍历一边线索化
void InThread(ThreadTree T) {
    if (T != NULL) {
        InThread(T->lchild); // 递归遍历左子树
        visit(T); // 访问根节点
        InThread(T->rchild); // 递归遍历右子树
    }
}
void visit(ThreadNode* q) {
    if (q->lchild == NULL) { // 左子树为空，建立前驱线索
        q->lchild = pre;
        q->ltag = 1;
    }
    if (pre != NULL && pre->rchild == NULL) { // 建立前驱结点的后继线索
        pre->rchild = q;
        pre->rtag = 1;
    }
    pre = q; // 更新前驱为当前结点
}
  //中序线索化二叉树T
  void CreatePreThread(ThreadTree T) {
      pre = NULL;//pre初始为空
      if (T != NULL) {//非空二叉树才能线索化
          InThread(T);//先序线索化二叉树
          if (pre->rchild == NULL)
              pre->rtag = 1;//处理遍历的最后一个结点
      }
  }

先序线索化

本质上就是一次先序遍历，只不过需要在一边遍历一边处理结点线索化

代码：

//全局变量pre 指向当前访问结点的前驱
ThreadNode* pre = NULL;

struct ElemType {
    int value;
};

//线索二叉树结点
typedef struct ThreadNode {
    ElemType data;
    struct ThreadNode* lchild, * rchild;
    int ltag, rtag;//左、右线索标志
} ThreadNode, * ThreadTree;
//先序遍历二叉树，一边遍历一边线索化
void PreThread(ThreadTree T) {
    if (T != NULL) {
        visit(T); // 访问根节点
        if(T->ltag==0)//lchild不是前驱线索
            PreThread(T->lchild); // 递归遍历左子树
        if (T->rtag==0)//rchild不是前驱线索
            PreThread(T->rchild); // 递归遍历右子树
    }
}
void visit(ThreadNode* q) {
    if (q->lchild == NULL) { // 左子树为空，建立前驱线索
        q->lchild = pre;
        q->ltag = 1;
    }
    if (pre != NULL && pre->rchild == NULL) { // 建立前驱结点的后继线索
        pre->rchild = q;
        pre->rtag = 1;
    }
    pre = q; // 更新前驱为当前结点
}
//先序线索化二叉树T
    void CreatePreThread(ThreadTree T){
        pre = NULL;//pre初始为空
        if (T != NULL) {//非空二叉树才能线索化
            PreThread(T);//先序线索化二叉树
            if (pre->rchild == NULL)
                pre->rtag = 1;//处理遍历的最后一个结点
        }
}

注意：若在PreThread函数中不添加

 if(T->ltag==0)

可能会导致某一结点的pre指针陷入无限循环 

后序线索化

本质上就是一次后序遍历，只不过需要在一边遍历一边处理结点线索化

代码：

//全局变量pre 指向当前访问结点的前驱
ThreadNode* pre = NULL;

struct ElemType {
    int value;
};

//线索二叉树结点
typedef struct ThreadNode {
    ElemType data;
    struct ThreadNode* lchild, * rchild;
    int ltag, rtag;//左、右线索标志
} ThreadNode, * ThreadTree;
//后序遍历二叉树，一边遍历一边线索化
void PostThread(ThreadTree T) {
    if (T != NULL) {
        PostThread(T->lchild); // 递归遍历左子树
        PostThread(T->rchild); // 递归遍历右子树
        visit(T); // 访问根节点
    }
}
void visit(ThreadNode* q) {
    if (q->lchild == NULL) { // 左子树为空，建立前驱线索
        q->lchild = pre;
        q->ltag = 1;
    }
    if (pre != NULL && pre->rchild == NULL) { // 建立前驱结点的后继线索
        pre->rchild = q;
        pre->rtag = 1;
    }
    pre = q; // 更新前驱为当前结点
}
//后序线索化二叉树T
    void CreatePreThread(ThreadTree T){
        pre = NULL;//pre初始为空
        if (T != NULL) {//非空二叉树才能线索化
            PostThread(T);//先序线索化二叉树
            if (pre->rchild == NULL)
                pre->rtag = 1;//处理遍历的最后一个结点
        }
}

为什么中序线索化和后序线索化不会遇到怕死循环问题 ：

中序线索化：

1. 线索化时机：在中序线索化过程中，一个节点的左线索是在其左子树遍历完成之后设置的，而右线索是在其右子树遍历完成之后设置的。这意味着在设置线索时，子树的遍历已经完成，因此不会覆盖未遍历的子节点指针。

2. 线索标志：中序线索化过程中，每个节点有两个线索标志 ltag 和 rtag。在遍历过程中，如果 ltag 为 0，则表示左孩子指针指向的是实际的左子节点，需要继续递归遍历；如果为 1，则表示左孩子指针是指向中序前驱的线索。同样，rtag 用于指示右孩子指针是否为线索。

3. 遍历顺序：中序遍历的顺序是左-根-右。这意味着在访问任何一个节点之前，它的左子树已经完全遍历并线索化，而它的右子树尚未遍历。因此，设置左线索是安全的，因为它不会影响右子树的遍历。

后序线索化：

1. 线索化时机：在后序线索化过程中，节点的左线索和右线索是在其后序遍历的相应位置设置的。与中序线索化类似，这意味着在设置线索时，子树的遍历已经完成。

2. 线索标志：后序线索化同样使用线索标志来区分子节点指针和线索。在遍历过程中，如果 ltag 为 0，则表示左孩子指针指向实际的左子节点；如果为 1，则表示左孩子指针是指向后序前驱的线索。右线索的设置是在遍历右子树和根节点之后。

3. 遍历顺序：后序遍历的顺序是左-右-根。在设置右线索之前，右子树已经被完全遍历和线索化，因此不会影响到后续的遍历过程。

总的来说，中序和后序线索化之所以不会遇到先序线索化中的死循环问题，是因为它们在设置线索时已经完成了子树的遍历，因此不会覆盖未遍历的子节点指针。而先序线索化则需要额外注意，因为线索化可能发生在遍历子树之前，如果不正确处理，就可能会覆盖子节点指针，导致死循环。

总结：