搜索二叉树

搜索二叉树：

        1 左子树上所有节点的值均小于它的根节点的值。

        2 右子树上所有节点的值均大于它的根节点。

        3 左右子树也分别为二叉搜索树。

这些特性使得在搜索二叉树中进行查找，插入，删除等错做的时间复杂度为（logn），其中n是节点的个数。

操作：

        1 插入操作 2 查找：在树中查找一个给定的值。3 删除：删除特定节点。4 遍历

代码中我做了详细的注解。各位看客老爷认真看代码注解

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

// 定义二叉搜索树节点结构体
typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

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

// 插入节点
TreeNode* insertNode(TreeNode* root, int val) {
    if (root == NULL) {
        return createNode(val);
    }
    if (val < root->val) {
        root->left = insertNode(root->left, val);
    } else if (val > root->val) {
        root->right = insertNode(root->right, val);
    }
    return root;
}

// 删除节点
TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == NULL) {
        return NULL;
    }//判断树是否为空


    //找找到节点
    if (val < root->val) {
        root->left = deleteNode(root->left, val);
    } 
    else if (val > root->val) {
        root->right = deleteNode(root->right, val);
    } 
    //当val=root-val时找到了节点进行下面操作


    //找到之后进行的操作
    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 = root->right;
        while (temp->left != NULL) {
            temp = temp->left;
        }

        //在左/右子树中删除找到的替换节点
        root->val = temp->val;
        root->right = deleteNode(root->right, temp->val);
    }
    //返回值是根节点
    return root;
}

// 查找节点
TreeNode* searchNode(TreeNode* root, int val) {
    if (root == NULL || root->val == val) {
        return root;
    }
    if (val < root->val) {
        return searchNode(root->left, val);
    } else {
        return searchNode(root->right, val);
    }
}

// 查找最小值，最小值在根节点的左子树上，对左子树向左循环搜索找到最小值
int findMin(TreeNode* root) {
    while (root->left != NULL) {
        root = root->left;
    }
    return root->val;
}

// 查找最大值，最大值在根节点的右子树上，对右子树向右循环搜索找到最大值
int findMax(TreeNode* root) {
    while (root->right != NULL) {
        root = root->right;
    }
    return root->val;
}

/* 中序遍历，这里只是通用的中序遍历，还有一种特殊的中序遍历可以节省
二叉树浪费空间的问题，
有兴趣的话可以看看我之前的的关于二叉搜索树的一篇文章。*/
void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->val);
        inorderTraversal(root->right);
    }
}

int main() {
    TreeNode* root = NULL;
    root = insertNode(root, 5);
    root = insertNode(root, 3);
    root = insertNode(root, 7);
    root = insertNode(root, 1);
    root = insertNode(root, 9);
    printf("Inorder traversal: ");
    inorderTraversal(root);
    printf("\n");
    root = deleteNode(root, 3);
    printf("Inorder traversal after deleting 3: ");
    inorderTraversal(root);
    printf("\n");
    TreeNode* node = searchNode(root, 7);
    if (node != NULL) {
        printf("Found node with value 7\n");
    } else {
        printf("Node with value 7 not found\n");
    }
    int minVal = findMin(root);
    printf("Minimum value: %d\n", minVal);
    int maxVal = findMax(root);
    printf("Maximum value: %d\n", maxVal);
    return 0;
}

        前序遍历结果：1，2，4，5，3，6，7

        中序遍历结果：4，2，5，1，6，7，3

        后序遍历结果：4，5，2，6，7，3，1