【数据结构】二叉搜索树

已于 2023-03-05 10:12:11 修改
阅读量91 收藏
点赞数
分类专栏： 数据结构系列 文章标签： 数据结构 c++ 开发语言
于 2022-10-05 00:05:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sustzc/article/details/127168249
版权

1. Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG -std=c99

SOURCE = $(wildcard ./*.c)
BIN = $(patsubst %.c, %, $(notdir $(SOURCE)))

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)

2. binary_search_tree.h

/*
* File Name: binary_search_tree.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __BINARY_SEARCH_TREE_H__
#define __BINARY_SEARCH_TREE_H__

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

#ifdef __cplusplus
extern "C" {
#endif

typedef int binary_search_tree_data_t;
typedef struct binary_search_tree_s {
    binary_search_tree_data_t data;
    struct binary_search_tree_s *left;
    struct binary_search_tree_s *right;
} binary_search_tree_t;

bool binary_search_tree_insert_data(binary_search_tree_t **root,
                                    binary_search_tree_data_t data);

bool binary_search_tree_insert_data_recursion(binary_search_tree_t **root,
                                              binary_search_tree_data_t data);

binary_search_tree_t *binary_search_tree_find_data(
        const binary_search_tree_t *root,
        binary_search_tree_data_t data);

binary_search_tree_t *binary_search_tree_find_data_recursion(
        const binary_search_tree_t *root,
        binary_search_tree_data_t data);

bool binary_search_tree_remove_data(binary_search_tree_t **root,
                                    binary_search_tree_data_t data);

bool binary_search_tree_remove_data_recursion(binary_search_tree_t **root,
                                              binary_search_tree_data_t data);

void binary_search_tree_in_order_recursion(const binary_search_tree_t *root);

void destroy_binary_search_tree(binary_search_tree_t **root);

#ifdef __cplusplus
}
#endif

#endif // __BINARY_SEARCH_TREE_H__

3. binary_search_tree.c

/*
* File Name: binary_search_tree.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "binary_search_tree.h"

static binary_search_tree_t *create_binary_search_tree(binary_search_tree_data_t data)
{
    binary_search_tree_t *new_binary_search_tree = NULL;

    do {
        new_binary_search_tree = (binary_search_tree_t *)calloc(
                1, sizeof(binary_search_tree_t));
        if (NULL == new_binary_search_tree) {
            perror("calloc new_binary_search_tree fail");
            break;
        }

        new_binary_search_tree->data = data;
        new_binary_search_tree->left = new_binary_search_tree->right = NULL;
    } while (0);

    return new_binary_search_tree;
}

bool binary_search_tree_insert_data(binary_search_tree_t **root,
                                    binary_search_tree_data_t data)
{
    if (NULL == *root) {
        *root = create_binary_search_tree(data);
        return NULL != *root;
    }

    binary_search_tree_t *cur = *root;
    // 记录待插入节点的父节点
    binary_search_tree_t *parent = NULL;

    while (NULL != cur) {
        parent = cur;

        if (data == cur->data) {
            return false;
        } else if (data < cur->data) {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
    }

    if (data < parent->data) {
        // 要插入的节点 连接到 左子树
        parent->left = create_binary_search_tree(data);
    } else if (data > parent->data) {
        parent->right = create_binary_search_tree(data);
    }

    return true;
}

bool binary_search_tree_insert_data_recursion(binary_search_tree_t **root,
                                              binary_search_tree_data_t data)
{
    if (NULL == *root) {
        *root = create_binary_search_tree(data);
        return NULL != *root;
    }

    if (data == (*root)->data) {
        return false;
    } else if (data < (*root)->data) {
        return binary_search_tree_insert_data_recursion(&((*root)->left), data);
    } else {
        return binary_search_tree_insert_data_recursion(&((*root)->right), data);
    }
}

binary_search_tree_t *binary_search_tree_find_data(
        const binary_search_tree_t *root,
        binary_search_tree_data_t data)
{
    if (NULL == root) {
        return NULL;
    }

    binary_search_tree_t *cur = (binary_search_tree_t *)root;
    while (NULL != cur) {
        if (data == cur->data) {
            return cur;
        } else if (data < cur->data) {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
    }

    return NULL;
}

binary_search_tree_t *binary_search_tree_find_data_recursion(
        const binary_search_tree_t *root,
        binary_search_tree_data_t data)
{
    if (NULL == root || data == root->data) {
        return (binary_search_tree_t *)root;
    }

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

bool binary_search_tree_remove_data(binary_search_tree_t **root,
                                    binary_search_tree_data_t data)
{
    binary_search_tree_t *cur = *root;
    binary_search_tree_t *parent = NULL;

    while (NULL != cur) {
        if (data == cur->data) {
            if (NULL == cur->left) { /* 左孩子为空 */
                if (cur != *root) {
                    if (cur == parent->left) {
                        parent->left = cur->right;
                    } else {
                        parent->right = cur->right;
                    }
                } else {
                    *root = cur->right;
                }

                free(cur);
            } else if (NULL == cur->right) { /* 右孩子为空 */
                if (cur != *root) {
                    if (cur == parent->left) {
                        parent->left = cur->left;
                    } else {
                        parent->right = cur->left;
                    }
                } else {
                    *root = cur->left;
                }

                free(cur);
            } else {
                // 右子树中的最小节点
                binary_search_tree_t *min_right = cur->right;
                // 右子树中最小节点的父节点
                binary_search_tree_t *min_right_parent = cur;

                while (NULL != min_right->left) {
                    min_right_parent = min_right;
                    min_right = min_right->left;
                }

                cur->data = min_right->data;

                // 此时 min_right 的 左孩子是空, 因此需要连接 min_right->right
                if (min_right != min_right_parent->left) {
                    min_right_parent->right = min_right->right;
                } else {
                    min_right_parent->left = min_right->right;
                }

                free(min_right);
            }

            return true;
        } else {
            parent = cur;
        }

        if (data < cur->data) {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
    }

    return false;
}

bool binary_search_tree_remove_data_recursion(binary_search_tree_t **root,
                                              binary_search_tree_data_t data)
{
    if (NULL == root) {
        return false;
    }

    if (data < (*root)->data) {
        return binary_search_tree_remove_data_recursion(
                &((*root)->left), data);
    } else if (data > (*root)->data) {
        return binary_search_tree_remove_data_recursion(
                &((*root)->right), data);
    } else {
        if (NULL == (*root)->left) { /* 左孩子为空 */
            binary_search_tree_t *tmp = *root;
            // 连接 右子树即可
            *root = (*root)->right;
            free(tmp);
        } else if (NULL == (*root)->right) { /* 右孩子为空 */
            binary_search_tree_t *tmp = *root;
            // 连接 左子树即可
            *root = (*root)->left;
            free(tmp);
        } else { /* 左右孩子 均不为空 */
            // 右 > 根 > 左, 因此需要该问题化简为: 查找右子树中的最小节点
            binary_search_tree_t *min_right = (*root)->right;

            // 找到 右子树中 最小的节点, 也就是 右子树中最左边那个节点
            while (NULL != min_right->left) {
                min_right = min_right->left;
            }

            // 用 右子树中最小的节点 替换 要删除的节点
            (*root)->data = min_right->data;
            // 删除右子树中最小的节点
            binary_search_tree_remove_data_recursion(&((*root)->right), min_right->data);
        }

        return true;
    }
}

void binary_search_tree_in_order_recursion(const binary_search_tree_t *root)
{
    if (NULL != root) {
        binary_search_tree_in_order_recursion(root->left);
        printf("%d ", root->data);
        binary_search_tree_in_order_recursion(root->right);
    }
}

void destroy_binary_search_tree(binary_search_tree_t **root)
{
    if (NULL == *root) {
        return;
    }

    destroy_binary_search_tree(&((*root)->left));
    destroy_binary_search_tree(&((*root)->right));

    free(*root);
    *root = NULL;
}

4. test_binary_search_tree.c

/*
* File Name: test_binary_search_tree.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "binary_search_tree.h"

void test()
{
    binary_search_tree_t *root = NULL;
    int i = 0;

    printf("Insert data to binary search tree\n");

    if (!binary_search_tree_insert_data(&root, 5)) {
        printf("binary_search_tree_insert_data 5 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data(&root, 2)) {
        printf("binary_search_tree_insert_data 2 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data(&root, 3)) {
        printf("binary_search_tree_insert_data 3 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data(&root, 8)) {
        printf("binary_search_tree_insert_data 8 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data(&root, 9)) {
        printf("binary_search_tree_insert_data 9 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data(&root, 5)) {
        printf("binary_search_tree_insert_data 5 failed(line: %d)\n", __LINE__);
    }

    if (!binary_search_tree_insert_data_recursion(&root, 1)) {
        printf("binary_search_tree_insert_data_recursion 1 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data_recursion(&root, 7)) {
        printf("binary_search_tree_insert_data_recursion 7 failed(line: %d)\n", __LINE__);
    }
    if (!binary_search_tree_insert_data_recursion(&root, 5)) {
        printf("binary_search_tree_insert_data_recursion 5 failed(line: %d)\n", __LINE__);
    }

    printf("in_order binary_search_tree(recursion):\n");
    binary_search_tree_in_order_recursion(root);

    printf("\n\nFind data (0 ~ 9):\n");
    for (i = 0; i < 10; i++) {
        binary_search_tree_t *found = binary_search_tree_find_data(root, i);
        printf("data: %d, find result : %s\n", i, found ? "found" : "not found");
    }

    printf("\n\nFind data recursion (0 ~ 9):\n");
    for (i = 0; i < 10; i++) {
        binary_search_tree_t *found = binary_search_tree_find_data_recursion(root, i);
        printf("data: %d, find result : %s\n", i, found ? "found" : "not found");
    }

    printf("\nDelete data to binary search tree\n");

    printf("\nRemove 2\n");
    if (!binary_search_tree_remove_data(&root, 2)) {
        printf("binary_search_tree_remove_data 2 failed(line: %d)\n", __LINE__);
    }
    printf("in_order binary_search_tree(recursion):\n");
    binary_search_tree_in_order_recursion(root);

    printf("\nRemove 66\n");
    if (!binary_search_tree_remove_data(&root, 66)) {
        printf("binary_search_tree_remove_data 66 failed(line: %d)\n", __LINE__);
    }
    printf("in_order binary_search_tree(recursion):\n");
    binary_search_tree_in_order_recursion(root);

    printf("\nRemove 5\n");
    if (!binary_search_tree_remove_data_recursion(&root, 5)) {
        printf("binary_search_tree_remove_data_recursion 5 failed(line: %d)\n", __LINE__);
    }
    printf("in_order binary_search_tree(recursion):\n");
    binary_search_tree_in_order_recursion(root);

    printf("\ndestroy_binary_search_tree\n");
    destroy_binary_search_tree(&root);
    printf("in_order binary_search_tree(recursion):\n");
    binary_search_tree_in_order_recursion(root);
}

int main(void)
{
    test();

    return 0;
}
sustzc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA 数据结构 二叉搜索树的结构
weixin_42606045的博客
11-11 1740
7-2 二叉搜索树的结构 （30 分） 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科） 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确...
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 6989
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
数据结构-二叉搜索树
qq_43714814的博客
12-15 1283
数据结构-二叉搜索树
数据结构 二叉搜索树
11-27
二叉搜索树（Binary Search Tree，BST）是数据结构中的一种特殊类型，它是一种二叉树，具有以下特性： 1. 每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。 2. 节点...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
二叉搜索树（BST，Binary Search Tree），是数据结构中一种非常重要的树形数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于任何有效的节点...
【初阶数据结构】详解栈和队列（来自知识星空的一抹流光）
tianxiawushanu的博客
09-06 1220
本文主要讲解了栈和队列这两种数据结构。它们的概念，以及代码的实现均在本文形成呈现，干货满满！！！
14_L3缓存友好的数据结构
刘炫320的博客
09-11 439
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
数据结构（邓俊辉）学习笔记】排序 7——希尔排序：Shell 序列 + 输入敏感性
weixin_44399845的博客
09-08 1033
希尔排序：Shell 序列 + 输入敏感性
【数据结构】——1.1树
qq_43507078的博客
09-07 1054
树，二叉树
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 973
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
2.C_数据结构_线性表
Fresh_man111的博客
09-07 1091
线性表就是若干数据的一个线性序列。数学表达式：L：表名a0~an-1：数据元素n：表长，n>0是为非空表二元描述形式：D：数据元素D用 ai 表示，这个 i 范围是0~n-1R：关系用R表示，这个关系是，表示ai为ai+1的直接前驱，ai+1为ai的直接后继。：这符号称为有序对，xxx1是xxx2的直接前驱，xxx2是xxx1的直接后继。 xxx1和xxx2可以为一个或多个。
21_动态规划与数据结构结合
刘炫320的博客
09-11 380
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
从头开始嵌入式第三十八天（数据结构 双向链表）
最新发布
qq_64792908的博客
09-11 410
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 321
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构——(java版）Map与Set
2301_77993957的博客
09-11 533
哈希表是一种数据结构，其实现思想是基于通过数据的关键码与所存地址两者之间构建映射关系，能够一次直接从表中得到想要搜索的元素。数据的关键码与所存地址之间的关系由哈希函数实现，规则为：设定适合的哈希函数之后，输入的关键码通过哈希函数的计算得出所存的地址。由此构造出来的结构称为哈希表。哈希表相对于二叉搜索树以及其他查询方式，不需要与多个关键码比较，这极大提升了查询的效率。
【高阶数据结构】秘法（二）——图（一）：图的基本概念和存储结构
2301_80220607的博客
09-04 2714
数据结构在我们学习和工作中有很多帮助，尤其是图论在我们平时生活中也会有很多应用，欢迎各位大佬来观看这篇图论的基础文章！！！
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左子树所有节点的关键值（键值）小于根节点的关键值，而右子树所有节点的关键值大于根节点的关键值。AVL树则是一种自平衡的二叉搜索树，它保证...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值