二叉搜索树 - Binary Search Tree

实验内容

建立中序线索二叉树，并实现中序遍历

代码实现

1.为字符串建BST

typedef struct TreeNode {
    char* data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建新节点
TreeNode* createNode(char* data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = _strdup(data);
    if (newNode->data == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点到二叉树
TreeNode* insertNode(TreeNode* root, char* data) {
    if (root == NULL) {
        return createNode(data);
    }

    if (strcmp(data, root->data) < 0) {
        root->left = insertNode(root->left, data);
    }
    else {
        root->right = insertNode(root->right, data);
    }

    return root;
}

// 创建二叉树
TreeNode* createBinaryTree(char* data[], int size) {
    TreeNode* root = NULL;
    for (int i = 0; i < size; i++) {
        root = insertNode(root, data[i]);
    }
    return root;
}

// 中序遍历打印二叉树
void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%s ", root->data);
        inorderTraversal(root->right);
    }
}

// 释放二叉树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root->data);
        free(root);
    }
}

void test() {
    int size;
    printf("\nEnter the number of strings: ");
    scanf("%d", &size);

    // 动态分配数组来存储字符串
    char** data = (char**)malloc(size * sizeof(char*));
    if (data == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }

    // 读取字符串
    for (int i = 0; i < size; i++) {
        char buffer[100]; // 假设每个字符串最多100字符
        printf("Enter string %d: ", i + 1);
        scanf("%s", buffer);
        data[i] = _strdup(buffer);
        if (data[i] == NULL) {
            fprintf(stderr, "Memory allocation failed\n");
            exit(EXIT_FAILURE);
        }
    }

    TreeNode* root = createBinaryTree(data, size);

    printf("\nInorder traversal of the binary tree:\n");
    inorderTraversal(root);
    printf("\n");

    freeTree(root);

    // 释放字符串数组
    for (int i = 0; i < size; i++) {
        free(data[i]);
    }
    free(data);
}

int main() {
    printf("**************Character Sequence Binary Search Tree**********************\n");
    test();
    return 0;
}

//Banana Apple Cherry Mango Blueberry Orange Strawberry Grape Watermelon Pear

结果展示 

2.为字符序列建BST

// 定义二叉树节点结构
typedef struct TreeNode {
    char data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建新节点
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点到二叉树
TreeNode* insertNode(TreeNode* root, char data) {
    if (root == NULL) {
        return createNode(data);
    }

    if (data < root->data) {
        root->left = insertNode(root->left, data);
    }
    else {
        root->right = insertNode(root->right, data);
    }

    return root;
}

// 创建二叉树
TreeNode* createBinaryTree(char data[], int size) {
    TreeNode* root = NULL;
    for (int i = 0; i < size; i++) {
        root = insertNode(root, data[i]);
    }
    return root;
}

// 中序遍历打印二叉树
void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%c ", root->data);
        inorderTraversal(root->right);
    }
}

// 释放二叉树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

void test() {
    printf("**************Character Sequence Binary Search Tree**********************\n");
    printf("\nEnter the Character Sequence : ");
    char ch[100];
    scanf("%s", ch);
    int size = strlen(ch);

    TreeNode* root = createBinaryTree(ch, size);
    printf("\nInorder traversal of the binary tree: ");
    inorderTraversal(root);
    printf("\n");
    freeTree(root);
}

int main() {
    test();
    return 0;
}

 结果展示

3.优化---查找/删除字符

 

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

// 定义二叉树节点结构
typedef struct TreeNode {
    char data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建新节点
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点到二叉树
TreeNode* insertNode(TreeNode* root, char data) {
    if (root == NULL) {
        return createNode(data);
    }

    if (data < root->data) {
        root->left = insertNode(root->left, data);
    }
    else {
        root->right = insertNode(root->right, data);
    }

    return root;
}

// 查找数据
TreeNode* searchNode(TreeNode* root, char data) {
    if (root == NULL || root->data == data) {
        return root;
    }

    if (data < root->data) {
        return searchNode(root->left, data);
    }
    else {
        return searchNode(root->right, data);
    }
}

// 找到树中的最小值节点
TreeNode* findMinNode(TreeNode* root) {
    while (root->left != NULL) {
        root = root->left;
    }
    return root;
}

// 删除节点
TreeNode* deleteNode(TreeNode* root, char data) {
    if (root == NULL) {
        return root;
    }

    if (data < root->data) {
        root->left = deleteNode(root->left, data);
    }
    else if (data > root->data) {
        root->right = deleteNode(root->right, data);
    }
    else {
        // 找到要删除的节点
        if (root->left == NULL) {
            TreeNode* temp = root->right;
            free(root);
            return temp;
        }
        else if (root->right == NULL) {
            TreeNode* temp = root->left;
            free(root);
            return temp;
        }

        // 节点有两个子节点，找到右子树的最小值节点
        TreeNode* temp = findMinNode(root->right);
        root->data = temp->data;
        root->right = deleteNode(root->right, temp->data);
    }

    return root;
}

// 创建二叉树
TreeNode* createBinaryTree(char data[], int size) {
    TreeNode* root = NULL;
    for (int i = 0; i < size; i++) {
        root = insertNode(root, data[i]);
    }
    return root;
}

// 中序遍历打印二叉树
void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%c ", root->data);
        inorderTraversal(root->right);
    }
}

// 释放二叉树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

void test() {
    printf("**************Character Sequence Binary Search Tree**********************\n");
    printf("\nEnter the Character Sequence: ");
    char ch[100];
    scanf("%s", ch);
    int size = strlen(ch);

    TreeNode* root = createBinaryTree(ch, size);
    printf("\nInorder traversal of the binary tree: ");
    inorderTraversal(root);
    printf("\n");

    char searchChar;
    printf("\nEnter the character to search: ");
    scanf(" %c", &searchChar);
    TreeNode* foundNode = searchNode(root, searchChar);
    if (foundNode) {
        printf("Character '%c' found in the tree.\n", searchChar);
    }
    else {
        printf("Character '%c' not found in the tree.\n", searchChar);
    }

    char deleteChar;
    printf("\nEnter the character to delete: ");
    scanf(" %c", &deleteChar);
    root = deleteNode(root, deleteChar);
    printf("\nInorder traversal after deletion: ");
    inorderTraversal(root);
    printf("\n");

    freeTree(root);
}

int main() {
    test();
    return 0;
}

结果展示