基本数据结构--二叉搜索树示例代码

#include <stdlib.h> 
// 定义二叉搜索树节点的结构体 
typedef struct TreeNode { 
    void *data; 
    struct TreeNode *left; 
    struct TreeNode *right; 
} TreeNode; 
 
// 定义二叉搜索树的结构体 
typedef struct BinarySearchTree { 
    TreeNode *root; 
    // 比较函数指针，用于比较两个数据的大小 
    int (*compare)(const void *, const void *); 
    // 复制函数指针，用于复制数据 
    void *(*duplicate)(const void *); 
    // 释放函数指针，用于释放数据 
    void (*free_data)(void *); 
} BinarySearchTree; 
 
// 创建一个新的树节点 
TreeNode* createTreeNode(void *data, 
                         int (*compare)(const void *, const void *), 
                         void *(*duplicate)(const void *), 
                         void (*free_data)(void *)) { 
    TreeNode *newNode = (TreeNode*)malloc(sizeof(TreeNode)); 
    if (newNode == NULL) { 
        return NULL; 
    } 
    newNode->data = duplicate(data); 
    newNode->left = newNode->right = NULL; 
    return newNode; 
} 
 
// 创建一个新的二叉搜索树 
BinarySearchTree* createBinarySearchTree( 
    int (*compare)(const void *, const void *), 
    void *(*duplicate)(const void *), 
    void (*free_data)(void *)) { 
    BinarySearchTree *newTree = (BinarySearchTree*)malloc(sizeof(BinarySearchTree)); 
    if (newTree == NULL) { 
        return NULL; 
    } 
    newTree->root = NULL; 
    newTree->compare = compare; 
    newTree->duplicate = duplicate; 
    newTree->free_data = free_data; 
    return newTree; 
} 
 
// 插入一个新节点到二叉搜索树中 
void insertNode(BinarySearchTree *tree, void *data) { 
    TreeNode **current = &tree->root; 
    while (*current!= NULL) { 
        int cmp = tree->compare(data, (*current)->data); 
        if (cmp < 0) { 
            current = &(*current)->left; 
        } else if (cmp > 0) { 
            current = &(*current)->right; 
        } else { 
            // 处理重复数据的情况，这里简单地覆盖 
            tree->free_data((*current)->data); 
            (*current)->data = tree->duplicate(data); 
            return; 
        }
    } 
    *current = createTreeNode(data, tree->compare, tree->duplicate, tree->free_data); 
} 
// 查找一个节点 
TreeNode* search(BinarySearchTree *tree, void *data) { 
    TreeNode *current = tree->root; 
    while (current!= NULL) { 
        int cmp = tree->compare(data, current->data); 
        if (cmp < 0) { 
            current = current->left; 
        } else if (cmp > 0) { 
            current = current->right; 
        } else { 
            return current; 
        } 
    } 
    return NULL; 
} 
//前序遍历
static void _preOrder(TreeNode *node,void *(callback)(void *)){
     if (node!= NULL) { 
        callback(node->data);
        _preOrder(node->left,callback); 
        _preOrder(node->right,callback); 
    }               
}
void preOrder(BinarySearchTree *tree,void *(callback)(void *)){
    _preOrder(tree->root,callback);
}
//中序遍历
static void _inOrder(TreeNode *node,void *(callback)(void *)){
     if (node!= NULL) { 
        _inOrder(node->left,callback);
        callback(node->data); 
        _inOrder(node->right,callback); 
    }               
}
void inOrder(BinarySearchTree *tree,void *(callback)(void *)){
    _inOrder(tree->root,callback);
}
//后序遍历
static void _postOrder(TreeNode *node,void *(callback)(void *)){
     if (node!= NULL) { 
        _postOrder(node->left,callback);
        _postOrder(node->right,callback); 
        callback(node->data); 
    }               
}
void postOrder(BinarySearchTree *tree,void *(callback)(void *)){
    _postOrder(tree->root,callback);
}
//找到最小节点
static TreeNode *_findMin( TreeNode *node){
   while(node->left!=NULL){
      node=node->left;
   } 
   return node;
}
TreeNode *findMin(BinarySearchTree *tree){
   return _findMin(tree->root);
}
//找到最大节点
static TreeNode *_findMax( TreeNode *node){
   while(node->right!=NULL){
      node=node->right;
   } 
   return node;
}
TreeNode *findMax(BinarySearchTree *tree){
   return _findMax(tree->root);
}
//删除节点
static TreeNode* _deleteNode(TreeNode *node, void *data,int (*compare)(const void*,const void *)){
    if (node == NULL) { 
        return node; 
    } 
    if (compare(data, node->data) < 0) { 
        node->left = _deleteNode(node->left, data, compare); 
    } else if (compare(data, node->data) > 0) { 
        node->right = _deleteNode(node->right, data, compare); 
    } else { 
        if (node->left == NULL) { 
            TreeNode* temp =node->right; 
            free(node); 
            return temp; 
        } else if (node->right == NULL) { 
            TreeNode* temp = node->left; 
            free(node); 
            return temp; 
        } 
        TreeNode* temp = _findMin(node->right); 
        node->data = temp->data; 
        node->right = _deleteNode(node->right, temp->data, compare); 
    } 
    return node; 
 
}
TreeNode* deleteNode(BinarySearchTree *tree,void *data){
   return _deleteNode(tree->root,data,tree->compare);
}
// 释放树节点内存 
void freeTreeNode(TreeNode *node, void (*free_data)(void *)) { 
    if (node == NULL) { 
        return; 
    } 
    freeTreeNode(node->left, free_data); 
    freeTreeNode(node->right, free_data); 
    free_data(node->data); 
    free(node); 
} 
 
// 释放整个二叉搜索树 
void freeBinarySearchTree(BinarySearchTree *tree) { 
    freeTreeNode(tree->root, tree->free_data); 
    free(tree); 
} 

#include <stdio.h> 
// 示例比较函数，用于整数类型 
int compareInt(const void *a, const void *b) { 
    return (*(int*)a - *(int*)b); 
} 
 
// 示例复制函数，用于整数类型 
void* duplicateInt(const void *a) { 
    int *newInt = (int*)malloc(sizeof(int)); 
    if (newInt == NULL) { 
        return NULL; 
    } 
    *newInt = *(int*)a; 
    return newInt; 
} 
//示例处理函数用于整数遍历
static int index=0;
void handleInt(void *d){
  	printf("%4d:%d\n",index++,*(int*)d); 
} 
// 示例释放函数，用于整数类型 
void freeInt(void *a) { 
    free(a); 
} 
 
int main() { 
    // 创建一个用于整数的二叉搜索树 
    BinarySearchTree *tree = createBinarySearchTree(compareInt, duplicateInt, freeInt); 
    if (tree == NULL) { 
        return 1; 
    } 
 
    // 插入一些整数 
    int num1 = 5; 
    int num2 = 3; 
    int num3 = 7; 
    insertNode(tree, &num1); 
    insertNode(tree, &num2); 
    insertNode(tree, &num3); 
 
    // 查找一个整数 
    int searchNum = 3; 
    TreeNode *foundNode = search(tree, &searchNum); 
    if (foundNode!= NULL) { 
        printf("找到节点，数据为: %d\n", *(int*)foundNode->data); 
    } else { 
        printf("未找到节点\n"); 
    } 
    printf(".....\n");index=0;
    preOrder(tree,handleInt);
    printf(".....\n");index=0;
    inOrder(tree,handleInt);
    printf(".....\n");index=0;
    postOrder(tree,handleInt);
    // 释放二叉搜索树 
    freeBinarySearchTree(tree); 
 
    return 0; 
}