二叉树的（先序/中序）线索化+遍历 C语言

想要成为社畜的大学生

已于 2024-02-28 12:56:15 修改

阅读量307

点赞数 2

CC 4.0 BY-SA版权

文章标签：算法数据结构

于 2024-01-26 21:39:16 首次发布

本文链接：https://blog.youkuaiyun.com/zxxcccc11/article/details/135875347

本文介绍了如何在二叉树中实现先序和中序遍历的线索化，包括创建节点、设置线索标志位以及遍历过程，展示了使用C语言的具体实现步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

// 定义二叉树节点结构
typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
    int leftThread;  // 左线索标志位，0表示指向左子树，1表示指向前驱节点
    int rightThread; // 右线索标志位，0表示指向右子树，1表示指向后继节点
}TreeNode;

// 创建新节点
TreeNode* createNode(int data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    newNode->leftThread = 0;
    newNode->rightThread = 0;
    return newNode;
}
TreeNode* getfirst(TreeNode* T) {
    while (T->leftThread==0)
    {
        T = T->left;
    }
    if (T->rightThread==0)
    {
        return getfirst(T->right);
    }
    return T;
}
// 先序遍历线索化二叉树
void postorderThreaded(TreeNode* root, TreeNode** pre) {
    if (root) {
        postorderThreaded(root->left, pre);
        postorderThreaded(root->right, pre);

        if (root->leftThread == 0) {
            root->leftThread = 1;
            root->left = *pre;
        }

        if (*pre && !(*pre)->right) {
            (*pre)->rightThread = 1;
            (*pre)->right = root;
        }

        *pre = root;
    }
}
// 中序遍历线索化二叉树
void inorderThreaded(TreeNode*root,TreeNode**pre) {
    if (root)
    {
        inorderThreaded(root->left, pre);
        if (!root->left)
        {
            root->leftThread = 1;
            root->left = *pre;
        }
        if (*pre&& !(*pre)->right)
        {
            
            (*pre)->right = root;
            (*pre)->rightThread = 1;
        }
        *pre = root;
        inorderThreaded(root->right, pre);
    }
}

// 先序遍历线索二叉树
void preorderTraversal(TreeNode* T) {
    TreeNode* pnode = T;
    TreeNode* pnextnode = NULL;
    while (pnode != NULL) {
        if (pnode->leftThread == 0) {
            printf("%d", pnode->data);
            pnextnode = pnode->left;
            pnode = pnextnode;
        }
        else {
            printf("%d", pnode->data);
            pnextnode = pnode->right;
            pnode = pnextnode;
        }
    }
}
// 中序遍历线索二叉树
void inorderTraversal(TreeNode* root) {
    TreeNode* current = root;

    while (current != NULL) {
        while (current->leftThread == 0)
        {
            current = current->left;
        }
        printf("%d ", current->data);
        while (current->rightThread == 1)
        {
            current = current->right;
            printf("%d ", current->data);
        }
        current = current->right;
    }
}
int main() {
    // 创建二叉树
    TreeNode* root = createNode(1);
    root->left = createNode(2);    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    root->right->right = createNode(7);
    /*
    先序线索化二叉树
    TreeNode* pre = NULL;
    preorderTreaded(root, &pre);
    printf("先序遍历线索二叉树结果：");
    preorderTraversal(root);
    */ 

    /*
    中序线索化二叉树
     TreeNode* pre = NULL;
     inorderThreaded(root, &pre);
     printf("中序遍历线索二叉树结果：");
     preorderTraversal(root);
    */
}

参考：

分类: Data Structure | tyrantlucifer