线索二叉树

Fifty Lm

已于 2024-04-17 22:48:51 修改

阅读量393

点赞数 5

文章标签：算法

于 2024-04-17 22:42:51 首次发布

本文链接：https://blog.csdn.net/2301_79641560/article/details/137892600

版权

本文详细介绍了线索二叉树的概念，包括先序、中序和后序线索二叉树的建立，以及在搜索二叉树中实现的插入、查找、前序、中序和后序遍历算法。通过实例展示了如何使用C语言创建和操作搜索二叉树。

摘要由CSDN通过智能技术生成

自己输入节点＋图表示一、问题分析：

线索二叉树是在普通二叉树的基础上添加了指向前驱和后继节点的线索（线索即直接指向的意思）。线索二叉树的建立主要分为先序线索二叉树、中序线索二叉树和后序线索二叉树。

二、主要算法描述--原型：

在这个二叉搜索树的实现中，主要涉及到以下几个算法：

创建新节点（createNode）：

输入：节点的值（整数）。

输出：创建并返回包含给定值的新节点。

插入节点（insert）：

输入：当前树的根节点和要插入的值。

输出：插入值后的新树的根节点。

算法描述：

如果树为空，创建一个新的节点作为根节点。

如果值小于当前节点的值，递归地插入到左子树中。

如果值大于当前节点的值，递归地插入到右子树中。

查找节点（search）：

输入：当前树的根节点和要查找的值。

输出：找到的节点或 NULL（如果值不存在）。

算法描述：

如果树为空或者找到了匹配的值，返回当前节点。

如果值小于当前节点的值，在左子树中递归查找。

如果值大于当前节点的值，在右子树中递归查找。

前序遍历（preorderTraversal）：

输入：当前树的根节点。

输出：前序遍历的结果。

算法描述：

访问当前节点。

递归地前序遍历左子树。

递归地前序遍历右子树。

中序遍历（inorderTraversal）：

输入：当前树的根节点。

输出：中序遍历的结果。

算法描述：

递归地中序遍历左子树。

访问当前节点。

递归地中序遍历右子树。

后序遍历（postorderTraversal）：

输入：当前树的根节点。

输出：后序遍历的结果。

算法描述：

递归地后序遍历左子树。

递归地后序遍历右子树。

访问当前节点。

打印树形状（printTree）：

输入：当前树的根节点和层次间隔。

输出：在终端上打印树的形状。

算法描述：

递归地打印右子树，增加层次间隔。

打印当前节点，使用层次间隔对齐。

递归地打印左子树，增加层次间隔。

主要算法思路--条列式：

搜索二叉树（Binary Search Tree，BST）是一种特殊的二叉树，具有以下性质：

左子树上所有节点的值小于根节点的值。
右子树上所有节点的值大于根节点的值。
左右子树也分别是搜索二叉树。

这个性质保证了在搜索二叉树中，每个节点的值都大于其左子树中的任何节点的值，且小于其右子树中的任何节点的值。因此，搜索二叉树的结构有助于高效地进行搜索、插入和删除等操作。

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

// 定义搜索二叉树节点
struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 创建新节点
struct TreeNode* createNode(int value) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点
struct TreeNode* insert(struct TreeNode* root, int value) {
    // 如果树为空，创建一个新的节点作为根节点
    if (root == NULL) {
        return createNode(value);
    }

    // 插入左子树
    if (value < root->data) {
        root->left = insert(root->left, value);
    }
    // 插入右子树
    else if (value > root->data) {
        root->right = insert(root->right, value);
    }

    // 如果值相等，什么也不做（假设树中不包含重复元素）

    return root;
}

// 查找节点
struct TreeNode* search(struct TreeNode* root, int value) {
    // 如果树为空或者找到了匹配的值，返回当前节点
    if (root == NULL || root->data == value) {
        return root;
    }

    // 如果值小于当前节点的值，在左子树中查找
    if (value < root->data) {
        return search(root->left, value);
    }
    // 如果值大于当前节点的值，在右子树中查找
    else {
        return search(root->right, value);
    }
}

// 前序遍历搜索二叉树
void preorderTraversal(struct TreeNode* root) {
    if (root) {
        printf("%d ", root->data);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}

// 后序遍历搜索二叉树
void postorderTraversal(struct TreeNode* root) {
    if (root) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        printf("%d ", root->data);
    }
}

// 中序遍历搜索二叉树（用于验证结果）
void inorderTraversal(struct TreeNode* root) {
    if (root) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

int main() {
    struct TreeNode* root = NULL;

    // 插入节点
    root = insert(root, 5);
    insert(root, 3);
    insert(root, 8);
    insert(root, 2);
    insert(root, 4);
    insert(root, 7);
    insert(root, 9);

    // 查找节点
    int targetValue = 4;
    struct TreeNode* result = search(root, targetValue);

    // 打印结果
    if (result) {
        printf("节点 %d 已找到\n", targetValue);
    } else {
        printf("节点 %d 未找到\n", targetValue);
    }

    // 打印前序遍历结果
    printf("前序遍历结果：");
    preorderTraversal(root);
    printf("\n");

    // 打印中序遍历结果
    printf("中序遍历结果：");
    inorderTraversal(root);
    printf("\n");

    // 打印后序遍历结果
    printf("后序遍历结果：");
    postorderTraversal(root);
    printf("\n");

    return 0;
}

自己输入节点＋图表示

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

// 定义搜索二叉树节点
struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 创建新节点
struct TreeNode* createNode(int value) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点
struct TreeNode* insert(struct TreeNode* root, int value) {
    // 如果树为空，创建一个新的节点作为根节点
    if (root == NULL) {
        return createNode(value);
    }

    // 插入左子树
    if (value < root->data) {
        root->left = insert(root->left, value);
    }
    // 插入右子树
    else if (value > root->data) {
        root->right = insert(root->right, value);
    }

    // 如果值相等，什么也不做（假设树中不包含重复元素）

    return root;
}

// 打印二叉树
void printTree(struct TreeNode* root, int space) {
    if (root == NULL) {
        return;
    }

    // 增加间隔，使树形结构更明显
    space += 5;

    // 打印右子树
    printTree(root->right, space);

    // 打印当前节点
    printf("\n");
    for (int i = 5; i < space; i++)
        printf(" ");
    printf("%d\n", root->data);

    // 打印左子树
    printTree(root->left, space);
}

// 查找节点
struct TreeNode* search(struct TreeNode* root, int value) {
    // 如果树为空或者找到了匹配的值，返回当前节点
    if (root == NULL || root->data == value) {
        return root;
    }

    // 如果值小于当前节点的值，在左子树中查找
    if (value < root->data) {
        return search(root->left, value);
    }
    // 如果值大于当前节点的值，在右子树中查找
    else {
        return search(root->right, value);
    }
}

// 前序遍历搜索二叉树
void preorderTraversal(struct TreeNode* root) {
    if (root) {
        printf("%d ", root->data);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}

// 中序遍历搜索二叉树（用于验证结果）
void inorderTraversal(struct TreeNode* root) {
    if (root) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

// 后序遍历搜索二叉树
void postorderTraversal(struct TreeNode* root) {
    if (root) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        printf("%d ", root->data);
    }
}

int main() {
    struct TreeNode* root = NULL;

    int numNodes;
    printf("输入节点数量：");
    scanf("%d", &numNodes);

    printf("输入节点值（以空格分隔）：");
    for (int i = 0; i < numNodes; ++i) {
        int value;
        scanf("%d", &value);
        root = insert(root, value);
    }

    // 查找节点
    int targetValue;
    printf("输入要查找的节点值：");
    scanf("%d", &targetValue);

    struct TreeNode* result = search(root, targetValue);

    // 打印结果
    if (result) {
        printf("节点 %d 已找到\n", targetValue);
    } else {
        printf("节点 %d 未找到\n", targetValue);
    }

    // 打印二叉树形状
    printf("二叉搜索树形状：\n");
    printTree(root, 0);

    // 打印前序遍历结果
    printf("\n前序遍历结果：");
    preorderTraversal(root);
    printf("\n");

    // 打印中序遍历结果
    printf("中序遍历结果：");
    inorderTraversal(root);
    printf("\n");

    // 打印后序遍历结果
    printf("后序遍历结果：");
    postorderTraversal(root);
    printf("\n");

    return 0;
}

自己输入节点

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

// 定义搜索二叉树节点
struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 创建新节点
struct TreeNode* createNode(int value) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点
struct TreeNode* insert(struct TreeNode* root, int value) {
    // 如果树为空，创建一个新的节点作为根节点
    if (root == NULL) {
        return createNode(value);
    }

    // 插入左子树
    if (value < root->data) {
        root->left = insert(root->left, value);
    }
    // 插入右子树
    else if (value > root->data) {
        root->right = insert(root->right, value);
    }

    // 如果值相等，什么也不做（假设树中不包含重复元素）

    return root;
}

// 查找节点
struct TreeNode* search(struct TreeNode* root, int value) {
    // 如果树为空或者找到了匹配的值，返回当前节点
    if (root == NULL || root->data == value) {
        return root;
    }

    // 如果值小于当前节点的值，在左子树中查找
    if (value < root->data) {
        return search(root->left, value);
    }
    // 如果值大于当前节点的值，在右子树中查找
    else {
        return search(root->right, value);
    }
}

// 前序遍历搜索二叉树
void preorderTraversal(struct TreeNode* root) {
    if (root) {
        printf("%d ", root->data);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}

// 中序遍历搜索二叉树（用于验证结果）
void inorderTraversal(struct TreeNode* root) {
    if (root) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

// 后序遍历搜索二叉树
void postorderTraversal(struct TreeNode* root) {
    if (root) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        printf("%d ", root->data);
    }
}

int main() {
    struct TreeNode* root = NULL;

    int numNodes;
    printf("输入节点数量：");
    scanf("%d", &numNodes);

    printf("输入节点值（以空格分隔）：");
    for (int i = 0; i < numNodes; ++i) {
        int value;
        scanf("%d", &value);
        root = insert(root, value);
    }

    // 查找节点
    int targetValue;
    printf("输入要查找的节点值：");
    scanf("%d", &targetValue);

    struct TreeNode* result = search(root, targetValue);

    // 打印结果
    if (result) {
        printf("节点 %d 已找到\n", targetValue);
    } else {
        printf("节点 %d 未找到\n", targetValue);
    }

    // 打印前序遍历结果
    printf("前序遍历结果：");
    preorderTraversal(root);
    printf("\n");

    // 打印中序遍历结果
    printf("中序遍历结果：");
    inorderTraversal(root);
    printf("\n");

    // 打印后序遍历结果
    printf("后序遍历结果：");
    postorderTraversal(root);
    printf("\n");

    return 0;
}