[数据结构]：20-线索二叉树（无头结点）（C语言实现）_c语言实现二叉链表非顺序二叉树查找结点-CSDN博客

#include "./Head/ThreadTreeData.h"
#include "./Source/ThreadTreeCommon.cpp"
#include "./Source/ThreadTreeFunction.cpp"

int main() {
    // 层序创建树
    ThreadTree TTree = NULL;
    int value[MaxSize] = {5, 3, 2, 4, 8, 6, 9, 0};
    TreeCreateSeq(TTree, value);
    /*---------------------------------------前序------------------------------------------*/
//    // 前序线索化
//    CreatePreThread(TTree);
//    // 获取中序遍历第一个结点
//    ThreadTNode *p = TTree; // 5
//    p = p->rChild; // 8
    p = p->lChild;
//
//    // 获取后继结点
//    p = GetPreNextNode(p);
//    printf("NextNode Value = %d\n", p->data);
//
//    // 前序遍历
//    PreOrder(TTree);

    /*---------------------------------------中序------------------------------------------*/
//    // 中序线索化
//    CreateInThread(TTree);
//
//    // 获取中序遍历第一个结点
//    ThreadTNode *p = GetInFirstNode(TTree);
//    printf("FirstNode Value = %d\n", p->data);
//
//    p = p->rChild; // 3
//    p = p->rChild; // 4
//    ThreadTNode *p1 = p; // 4
//    p = p->rChild; // 5
//    printf("NowNode Value = %d\n", p->data);
//
//    // 获取前驱结点
//    p1 = GetInPreNode(p);
//    printf("PreNode Value = %d\n", p1->data);
//
//    // 获取后续结点
//    p = GetInNextNode(p);
//    printf("NextNode Value = %d\n", p->data);
//    printf("--------------------------------------\n");
//
//    // 中序遍历
//    InOrder(TTree);

    /*---------------------------------------后序------------------------------------------*/
    // 后序线索化
    CreatePostThread(TTree);
    ThreadTNode *p = TTree; // 5
    p = p->rChild; // 8

    // 获取前驱结点
    p = GetPostPreNode(p);
    printf("PreNode Value = %d\n", p->data);

    // 后序遍历-逆序输出
    // 可通过栈实现逆置(或者数组的原地逆置)
    PostOrder(TTree);
    return 0;
}

02-头文件

用于存储结构体和常量等。

//
// Created by 24955 on 2023-02-26.
//

#ifndef INC_01_ARRAYQUEUE_QUEUEDATA_H
#define INC_01_ARRAYQUEUE_QUEUEDATA_H
// 头文件
#include <stdio.h>
#include <stdlib.h>

// 常量
#define MaxSize 10
typedef int ElemType;

// 结构体
// 二叉树
typedef struct ThreadTNode {
    ElemType data;
    struct ThreadTNode *lChild, *rChild;
    int lTag, rTag;
} ThreadTNode, *ThreadTree;
#endif //INC_01_ARRAYQUEUE_QUEUEDATA_H

03-ThreadTreeCommon.cpp

用于存储线索二叉树创建、线索化等公用函数。

//
// Created by 24955 on 2023-03-28.
// 不带头结点(408不存在带头结点的树)
//
/*---------------------------------------Common------------------------------------------*/
// 创建树-顺序创建
void TreeCreateSeq(ThreadTree &TTree, int Value[]) {
    /*
     * 1. 创建根结点
     * 2. 根据数值大小寻找待插入结点
     * 3. 插入结点*/
    ThreadTNode *NewThreadTNode;
    for (int i = 0; Value[i]; i++) {
        // 创建新结点
        NewThreadTNode = (ThreadTNode *) calloc(1, sizeof(ThreadTNode));
        NewThreadTNode->data = Value[i];
        NewThreadTNode->lTag = 0;
        NewThreadTNode->rTag = 0;
        // 判断是否为创建根节点
        if (TTree == NULL) {
            // 创建根节点
            TTree = NewThreadTNode;
        } else {
            ThreadTNode *pre = NULL; // 保存工作结点前驱
            ThreadTNode *p = TTree; // 当前工作结点
            while (p) {
                if (p->data >= Value[i]) {
                    pre = p;
                    p = p->lChild;
                } else {
                    pre = p;
                    p = p->rChild;
                }
            };
            // 找到待插入结点并插入数据
            if (pre->data >= Value[i]) {
                pre->lChild = NewThreadTNode;
            } else {
                pre->rChild = NewThreadTNode;
            }
        }
    }
}

// 处理函数
void ThreadVisit(ThreadTNode *p, ThreadTNode *&pre) {
    /*
     * 1. 判断当前结点左孩子是否为空
     * 2. 为空设置前驱线索
     * 3. 判断前驱右孩子是否为空
     * 4. 为空设置前驱后继线索*/
    // 线索化
    if (p->lChild == NULL) {
        p->lChild = pre;
        p->lTag = 1;
    }
    if (pre != NULL && pre->rChild == NULL) {
        pre->rChild = p;
        pre->rTag = 1;
    }
    pre = p;
}

/*---------------------------------------前序------------------------------------------*/
// 前序线索化递归函数
void PreThread(ThreadTNode *p, ThreadTNode *&pre) {
    /*
     * 1. 线索化
     * 2. 防止环的出现(转圈圈)*/
    if (p != NULL) {
        ThreadVisit(p, pre);
        if (p->lTag == 0) {
            PreThread(p->lChild, pre);
        }
        PreThread(p->rChild, pre);
    }
}

// 前序线索化
void CreatePreThread(ThreadTree TTree) {
    /*
     * 1. 线索化
     * 2. 设置最后一个结点*/
    ThreadTNode *pre = NULL;
    if (TTree != NULL) {
        PreThread(TTree, pre);
        if (pre->rChild == NULL) {
            pre->rTag = 1;
        }
    }
}

/*---------------------------------------中序------------------------------------------*/
// 中序线索化递归函数
void InThread(ThreadTNode *p, ThreadTNode *&pre) {
    /*
     * 1. 线索化*/
    if (p != NULL) {
        InThread(p->lChild, pre);
        ThreadVisit(p, pre);
        InThread(p->rChild, pre);
    }
}

// 中序线索化
void CreateInThread(ThreadTree TTree) {
    /*
     * 1. 线索化
     * 2. 设置最后一个结点*/
    ThreadTNode *pre = NULL;
    if (TTree != NULL) {
        InThread(TTree, pre);
        if (pre->rChild == NULL) {
            pre->rTag = 1;
        }
    }
}

/*---------------------------------------后序------------------------------------------*/
// 后序线索化递归函数
void PostThread(ThreadTNode *p, ThreadTNode *&pre) {
    /*
     * 1. 线索化*/
    if (p != NULL) {
        PostThread(p->lChild, pre);
        PostThread(p->rChild, pre);
        ThreadVisit(p, pre);
    }
}

// 后序线索化
void CreatePostThread(ThreadTree TTree) {
    /*
     * 1. 线索化*/
    ThreadTNode *pre = NULL;
    if (TTree != NULL) {
        PostThread(TTree, pre);
    }
}

04-ThreadTreeFunction.cpp

用于存储线索二叉树寻找前驱、后继结点和遍历等操作。

//
// Created by 24955 on 2023-03-28.
// 不带头结点(408不存在带头结点的树)
//
/*---------------------------------------Common------------------------------------------*/
// 处理函数
void PrintVisit(ThreadTNode *p) {
    printf("%3d", p->data);
}

/*---------------------------------------前序------------------------------------------*/
// 获取前序遍历某结点的后续结点
ThreadTNode *GetPreNextNode(ThreadTNode *p) {
    /*
     * 1. 若rTag == 0，则当前节点一定有右孩子 （根 左（根 左 右） 右）
     * 2. 判断是否含有左孩子，若有则左孩子便为当前结点后继
     * 3. 若没有左孩子，则其右孩子便为当前结点后继
     * 4. 若rTag == 1，直接返回线索化后的后继结点*/
    if (p->rTag == 0) {
        if (p->lChild != NULL && p->lTag == 0) {
            return p->lChild;
        } else {
            return p->rChild;
        }
    } else {
        return p->rChild;
    }
}

// 前序遍历
void PreOrder(ThreadTree TTree) {
    /*
     * 1. 获取当前树第一个访问结点(根结点)
     * 2. 依次获取其后继结点
     * 3. 空间复杂度O(1)*/
    ThreadTNode *p = TTree;
    while (p) {
        PrintVisit(p);
        p = GetPreNextNode(p);
    }
}

/*---------------------------------------中序------------------------------------------*/
// 获取中序遍历的第一个结点
ThreadTNode *GetInFirstNode(ThreadTNode *p) {
    /*
     * 1. 获取当前子树中第一个被访问的结点*/
    while (p->lTag == 0) {
        p = p->lChild;
    }
    return p;
}

// 获取中序遍历某结点的后续结点
ThreadTNode *GetInNextNode(ThreadTNode *p) {
    /*
     * 1. 若rTag == 0，则表明有右孩子，返回右子树中第一个被访问结点就是当前结点的后继结点
     * 2. 若rTag == 1，直接返回线索化后的后继结点*/
    if (p->rTag == 0) {
        return GetInFirstNode(p->rChild);
    } else {
        return p->rChild;
    }
}

// 获取中序遍历的最后一个结点
ThreadTNode *GetInLastNode(ThreadTNode *p) {
    /*
     * 1. 返回当前子树最后一个被访问的结点*/
    while (p->rTag == 0) {
        p = p->rChild;
    }
    return p;
}

// 获取中序遍历某结点的前驱结点
ThreadTNode *GetInPreNode(ThreadTNode *p) {
    /*
      * 1. 若lTag == 0，则表明有左孩子，返回左子树中最后一个被访问结点就是当前结点的前驱结点
      * 2. 若lTag == 1，直接返回线索化后的前驱结点*/
    if (p->lTag == 0) {
        return GetInLastNode(p->lChild);
    } else {
        return p->lChild;
    }
}

// 中序遍历
void InOrder(ThreadTree TTree) {
    /*
     * 1. 获取当前树第一个访问结点
     * 2. 依次获取其后继结点
     * 3. 空间复杂度O(1)*/
    for (ThreadTNode *p = GetInFirstNode(TTree); p; p = GetInNextNode(p)) {
        PrintVisit(p);
    }
}

/*---------------------------------------后序------------------------------------------*/
// 获取后序遍历某结点的前驱结点
ThreadTNode *GetPostPreNode(ThreadTNode *p) {
    /*
     * 1. 若lTag == 0，则当前节点一定有左孩子 （左 右 根（左 右 根））
     * 2. 判断是否含有右孩子，若有则右孩子便为当前结点后继
     * 3. 若没有右孩子，则其左孩子便为当前结点后继
     * 4. 若lTag == 1，直接返回线索化后的后继结点*/
    if (p->lTag == 0) {
        if (p->rChild != NULL && p->rTag == 0) {
            return p->rChild;
        } else {
            return p->lChild;
        }
    } else {
        return p->lChild;
    }
}

// 后序遍历-逆序输出
void PostOrder(ThreadTree TTree) {
    /*
    * 1. 获取当前树第一个访问结点(根结点)
    * 2. 依次获取其前驱结点
    * 3. 逆序输出
    * 4. 空间复杂度O(1)*/
    ThreadTNode *p = TTree;
    while (p) {
        PrintVisit(p);
        p = GetPostPreNode(p);
    }
}