Binary Search Tree C语言实现

最新推荐文章于 2024-04-21 18:12:02 发布
原创 最新推荐文章于 2024-04-21 18:12:02 发布 · 4.3k 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #搜索二叉树 #c语言

Binary Search Tree是数据结构中比较有用的一种二叉树结构，这种结构讲大量的数据进行平摊式分布，并且规定大的数在右边，小的数在左边，以这种方式存放的数据可以非常方便地做数据排序和检索。
关于BST的更多信息，可以查看这个链接（英文，讲的非常好，不得不赞）：http://algs4.cs.princeton.edu/32bst/
台湾国立清华大学韩永楷老师的MOOC(讲的超级棒，完爆国内，我的代码实现就是参考韩老师的课程内容)：http://www.icourse163.org/course/NTHU-451013#/info
下面给出使用C语言的实现方式，我使用了最简单的方式实现，代码中有很多注释，大家可以参考。代码可编译，可运行。

/*************************************************************************
    > File Name: bst.c
    > Author: Baniel Gao
    > Mail: createchance@163.com 
    > Created Time: Thu 01 Dec 2016 08:29:23 AM EST
 ************************************************************************/

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

typedef struct node_t {
    int key;
    struct node_t* parent;
    struct node_t* left;
    struct node_t* right;
} node;

/*
 * Get min number of this tree pointed by root.
 * 
 * Return min node pointer, NULL if root is NULL.
 */
node* min(node* root)
{
    node* min_node = root;

    if (root == NULL) {
        return NULL;
    }

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

    return min_node;
}

/*
 * Get max number of this tree pointed by root.
 * 
 * Return max node pointer, NULL if root is NULL.
 */
node* max(node* root)
{
    node* max_node = root;

    if (root == NULL)
    {
        return NULL;
    }

    while (max_node->right != NULL)
    {
        max_node = max_node->right;
    }

    return max_node;
}

/*
 * Search the number k.
 *
 * Return node pointer which contains the key, NULL if do not match anything.
 */
node* search(node* root, int k)
{
    node* current = root;

    if (root == NULL) {
        return NULL;
    }

    while (1) {
        if (current->key == k) {
            break;
        } else if (current->key > k) {
            current = current->left;
        } else {
            current = current->right;
        }

        if (current == NULL) {
            break;
        }
    }

    return current;
}

/*
 * Find the predeccessor of k.
 *
 * Return node pointer of predeccessor if success, NULL if find nothing.
 */
node* predecessor(node* root, int k)
{
    if (root == NULL)
    {
        return NULL;
    }

    node* target = search(root, k);
    if (target != NULL) {
        if (target->left != NULL) {
            target = max(target->left);
        } else {
            while (1) {
                if (target->parent == NULL) {
                    target = target->parent;
                    break;
                } else if (target == target->parent->right) {
                    target = target->parent;
                    break;
                } else if (target == target->parent->left) {
                    target = target->parent;
                }
            }
        }
    }

    return target;
}

/*
 * Find successor of number k.
 * 
 * Return node pointer of successor if success, NULL if find nothing.
 */
node* successor(node* root, int k)
{
    if (root == NULL) {
        return NULL;
    }

    node* target = search(root, k);
    if (target != NULL) {
        if (target->right != NULL) {
            target = min(target->right);
        } else {
            while (1) {
                if (target->parent == NULL) {
                    target = target->parent;
                    break;
                } else if (target == target->parent->left) {
                    target = target->parent;
                    break;
                } else if (target == target->parent->right) {
                    target = target->parent;
                }
            }
        }
    }

    return target;
}

/*
 * insert one number k to binary search tree.
 *
 * Return node pointer if success, NULL if key already exists.
 */
node* insert(node* root, int k)
{
    node* current = root;

    if (root == NULL) {
        root = (node*) malloc(sizeof(node));
        root->key = k;
        return root;
    }

    while (1) {
        if (current->key == k)
        {
            current = NULL;
            break;
        } else if (current->key > k) {
            if (current->left != NULL) {
                current = current->left;
            } else {
                // no left child, so we are left child, create one node and insert.
                node* new = (node*) malloc(sizeof(node));
                new->key = k;
                new->parent = current;
                new->left = NULL;
                new->right = NULL;
                current->left = new;
                // move current to target node.
                current = current->left;
                break;
            }
        } else if (current->key < k) {
            if (current->right != NULL) {
                current = current->right;
            } else {
                // no right child, so we are left child, create one node and insert.
                node* new = (node*) malloc(sizeof(node));
                new->key = k;
                new->parent = current;
                new->left = NULL;
                new->right = NULL;
                current->right = new;
                // move current to target node.
                current = current->right;
                break;
            }
        }
    }

    return current;
}

/*
 * Delete node contains number k.
 * 
 * Return 0 if succeed, -1 if number k not found or tree root is NULL, 1 if the tree is empty after deletion.
 */
int delete(node* root, int k)
{
    if (root == NULL) {
        return -1;
    }

    // Find this node first.
    node* target = search(root, k);

    // Well, we can not find this node.
    if (target == NULL) {
        return -1;
    }

    /* Case 1: this node is leaf node. */
    if (target->left == NULL && target->right == NULL) {
        if (target != root) {
            if (target == target->parent->right) {
                target->parent->right = NULL;
            } else {
                target->parent->left = NULL;
            }
        } else {
            root = NULL;
        }
        free(target);
    }
    /* Case 2: this node has only one child node. */
    else if (target->left != NULL && target->right == NULL) {
        // Case 2.1: this node only has a left child.
        if (target == root) {
            node* predecessor_node = predecessor(root, k);
            if (predecessor_node == NULL) {
                return -1;
            }

            // Replace the number first.
            target->key = predecessor_node->key;
            // predecessor does not have any child.
            if (predecessor_node->left == NULL && predecessor_node->right == NULL) {
                if (target->right == predecessor_node) {
                    target->right = NULL;
                } else {
                    predecessor_node->parent->left = NULL;
                }
            }
            // predecessor only have left child.
            else {
                predecessor_node->parent->right = predecessor_node->left;
                predecessor_node->left->parent = predecessor_node->parent;
            }
            // Free predecessor node.
            free(predecessor_node);
        } else {
            target->left->parent = target->parent;
            if (target == target->parent->left) {
                target->parent->left = target->left;
            } else {
                target->parent->right = target->left;
            }
        }
    } else if (target->left == NULL && target->right != NULL) {
        // Case 2.2: this node only has a right child.
        if (target == root) {
            node* successor_node = successor(root, k);
            if (successor_node == NULL) {
                return -1;
            }

            // Replace the number first.
            target->key = successor_node->key;
            // successor does not have any child.
            if (successor_node->left == NULL && successor_node->right == NULL) {
                if (target->right == successor_node) {
                    target->right = NULL;
                } else {
                    successor_node->parent->left = NULL;
                }
            }
            // successor only have right child.
            else {
                successor_node->parent->left = successor_node->right;
                successor_node->right->parent = successor_node->parent;
            }
            // Free successor node.
            free(successor_node);
        } else {
            target->right->parent = target->parent;
            if (target == target->parent->left) {
                target->parent->left = target->right;
            } else {
                target->parent->right = target->right;
            }
        }
    }
    /* Case 3: this node has two child node. */
    else if (target->left != NULL && target->right != NULL) {
        node* successor_node = successor(root, k);
        if (successor_node == NULL) {
            return -1;
        }

        // Replace the number first.
        target->key = successor_node->key;
        // Case 3.1: successor does not have any child.
        if (successor_node->left == NULL && successor_node->right == NULL) {
            if (target->right == successor_node) {
                target->right = NULL;
            } else {
                successor_node->parent->left = NULL;
            }
        }
        // Case 3.2: successor only have right child.
        else {
            successor_node->parent->left = successor_node->right;
            successor_node->right->parent = successor_node->parent;
        }
        // Free successor node.
        free(successor_node);
    }

    if (root == NULL) {
        return 1;
    }

    return 0;
}

/*
 * Modify one node'key. Change it from src to dst.
 *
 * Return the node modified, NULL if this node does not exist.
 */
node* modify(node* root, int src, int dst)
{
    if (root == NULL) {
        return NULL;
    }

    // We have to make sure the src exists and dst does not exist.
    node* source = search(root, src);
    node* destination = search(root, dst);

    if (source == NULL) {
        printf("The source number %d does not exist. \n", src);
        return NULL;
    }

    if (destination != NULL) {
        printf("The destination number %d already exist. \n", dst);
        return NULL;
    }

    // we delete the old node first.
    delete(root, src);
    // then insert new node.
    insert(root, dst);

    return source;
}

/*
 * Print this tree by inorder.
 * 
 * The numbers printed is sorted.
 */
void print_tree_inorder(node* root) {
    if(root != NULL) {
        print_tree_inorder(root->left);
        printf("%d ",root->key);
        print_tree_inorder(root->right);
    }
}

/*
 * Console helper function.
 */
void show_help()
{
    printf("1. insert\n");
    printf("2. delete\n");
    printf("3. modify\n");
    printf("4. search\n");
    printf("5. predeccessor\n");
    printf("6. successor\n");
    printf("7. min\n");
    printf("8. max\n");
    printf("9. print tree\n");
}

int main()
{
    char cmd;
    int key, key2;
    node* root = NULL;

    printf("This is a binary search tree demo.\n");
    while (1) {
        printf("Command<m for help>: ");
        fflush(stdout);
        scanf("%c", &cmd);

        if (cmd == 'm') {
            show_help();
        } else if (cmd == '1') {
            printf("Input number to insert: ");
            fflush(stdout);
            scanf("%d", &key);
            node* inserted_node = insert(root, key);
            if (root == NULL) {
                root = inserted_node;
            }
            if (inserted_node == NULL) {
                printf("The number %d already exist. \n", key);
            } else {
                printf("Complete!\n");
            }
        } else if (cmd == '2') {
            printf("Input number to delete: ");
            fflush(stdout);
            scanf("%d", &key);
            int ret = delete(root, key);
            if (ret < 0) {
                printf("The numnber %d does not exist. \n", key);
            } else if (ret == 1) {
                printf("The tree is empty now. \n");
                root = NULL;
            } else {
                printf("Complete!\n");
            }
        } else if (cmd == '3') {
            printf("Input the number you want to change from and to: ");
            fflush(stdout);
            scanf("%d %d", &key, &key2);
            node* modified_node = modify(root, key, key2);
            if (modified_node == NULL) {
                printf("Modify failed. \n");
            } else {
                printf("Complete!\n");
            }
        } else if (cmd == '4') {
            printf("Input the number you want to search: ");
            fflush(stdout);
            scanf("%d", &key);
            node* result = search(root, key);
            if (result == NULL) {
                printf("The number %d does not exist.\n", key);
            } else {
                printf("Complete!\n");
            }
        } else if (cmd == '5') {
            printf("Input the number you want to find predecessor: ");
            fflush(stdout);
            scanf("%d", &key);
            node* result = predecessor(root, key);
            if (result == NULL) {
                printf("Predecessor do not found!\n");
            } else {
                printf("Predecessor is %d. \n", result->key);
            }
        } else if (cmd == '6') {
            printf("Input the number you want to find successor: ");
            fflush(stdout);
            scanf("%d", &key);
            node* result = successor(root, key);
            if (result == NULL) {
                printf("Successor do not found!\n");
            } else {
                printf("Successor is %d. \n", result->key);
            }
        } else if (cmd == '7') {
            node* result = min(root);
            if (result != NULL) {
                printf("Min number is: %d. \n", result->key);
            } else {
                printf("This tree is empty! \n");
            }
        } else if (cmd == '8') {
            node* result = max(root);
            if (result != NULL) {
                printf("Max number is: %d. \n", result->key);
            } else {
                printf("This tree is empty! \n");
            }
        } else if (cmd == '9') {
            if (root != NULL) {
                print_tree_inorder(root);
                printf("\n");
            } else {
                printf("This tree is empty! \n");
            }
        }

        getchar();
    }

    return 0;
}

上面程序支持9中操作：
1. insert：插入一个数据，如果当前bst为空，那么新建根节点，并且赋值
2. delete：删除一个数据，如果给定数字不存在，则删除失败
3. modify：修改一个数据，需要源数据存在，且目标数据不能存在
4. search：检索一个数据，如果数据存在成功返回，反之失败
5. predeccessor：检索一个数的前导数（这个数必须存在于树中），就是比目标数小的所有数的最大数
6. successor：检索一个数的后导数（这个数必须存在于数中），就是比目标数大的所有数的最小数
7. min：检索树中最小的数
8. max：检索树中最大的数
9. print tree：按照中序打印树，对于BST来说中序就是所有数的升序排序
分别输入以上操作前的序号，就可以对BST发起操作。运行如下图：
这里写图片描述

Binary search tree C++
12-07
课上组内共同完成，由导师监督。有一定参考价值
C++算法：二分查找（Binary Search）
fk__boy的博客
08-23 6581
在枚举查找里，要一个不漏的查找完所有数据，最坏情况下时间复杂度为O(n)。这就导致程序的时间消耗非常巨大，若a数组的最大下标为1000000，则程序也需要查找1000000次，很容易导致TLE（Time Limit Exceeded）。那么有没有一种更快捷的方法呢？ 当然有，这就是二分查找法（Binary Search），想象一下，对于一个无序数列，我们当然只能枚举，但如果是一个有序数列，那么在查找的过程中就会有迹可循。
C++ STL中的Binary search（二分查找）
^.^
09-10 724
一.解释 　　以前遇到二分的题目都是手动实现二分，不得不说错误比较多，关于返回值，关于区间的左闭右开等很容易出错，最近做题发现直接使用STL中的二分函数方便快捷还不会出错，不过对于没有接触过的同学，二分函数确实是一个头疼的部分，自己查的内容又有点乱，找不到具体的使用方法，有必要自己总结一份完整的以后备用。 二.常用操作 1.头文件 #include <algorithm> 2.使用方法 a.binary_search：查找某个元素是否出现。 a.函数模板：binary_searc
C语言 二分查找法＜Binary Search＞（折半查找）具体实现
weixin_45803426的博客
12-13 2498
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。它充分利用了元素间的次序关系，采用分治策略（分半），可在最坏的情况下用O(log~2~n)完成搜索任务。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 具体过程代码实现如下：
C语言实现二分查找
wantsnowfly的博客
01-17 4811
相较于线性查找，二分查找在面对大量数据时的效率更高，但它的缺点是只能对有序数组进行查找。 源代码如下： #include<stdio.h> void binarysearch(int *a,int sum,int n) { int low=0; int high=sum-1; int key=n; int mid=0; int count=0; while(low<=high) { count++; ...
【C语言】C语言实现二分查找(折半查找)
weixin_53747462的博客
09-19 2520
C语言实现二分查找/静态库的简单使用
[leetcode]Validate Binary Search Tree (判断有效二叉搜索树 C语言实现)
道虽迩，不行不至；事虽小，不为不成
04-17 1638
Validate Binary Search Tree Given a binary tree, determine if it is a valid binary search tree (BST).Assume a BST is defined as follows:The left subtree of a node contains only nodes with keys less t
二叉排序树/二叉查找树 （binary sort tree/ binary search tree)的C语言实现
落枫的专栏
02-20 1745
二叉排序树（Binary Sort Tree）又称二叉查找树，亦称二叉搜索树。 它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树；     我们假设用二叉链表进行存储；二叉链表结点。有三个域：一个数据域，两个分别指向左右子结点的
二叉排序树查找c语言算法,二叉排序树/二叉查找树 （binary sort tree/ binary search tree)的C语言实现...
weixin_35626356的博客
05-23 625
二叉排序树(Binary Sort Tree)又称二叉查找树，亦称二叉搜索树。 它或者是一棵空树；或者是具有下列性质的二叉树： (1)若左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2)若右子树不空，则右子树上所有结点的值均大于它的根结点的值； (3)左、右子树也分别为二叉排序树；我们假设用二叉链表进行存储；二叉链表结点。有三个域：一个数据域，两个分别指向左右子结点的指针域。#inc...
04-树6 Complete Binary Search Tree (30分)(数据结构)(C语言实现)
shenbossed的博客
05-20 294
A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties: The left subtree of a node contains only nodes with keys less than the node’s key. The right subtree of a node contains only nodes with keys greater than
【C语言】整数的二进制以及移位操作符
Hacynn的博客
09-09 1150
二进制（binary），是在数学和数字电路中以2为基数的记数系统，是以2为基数代表系统的二进位制。这一系统中，通常用两个不同的符号0（代表零）和1（代表一）来表示。一个整数是4个字节（即32个bit位），因此一个整数的二进制序列就是32个bit位。编译器都是采用的算术移位，因为当一个数是负数时，逻辑移位会将它变成正数，太过于简单暴力了。的二进制表示形式有3种：原码，反码，补码。注：移位操作符的操作数只能是整数。移位规则：左边抛弃，右边补0。
C语言-二分查找
Jason_from_China的博客
04-21 1499
这个分支实际上永远不会执行，因为前面已经覆盖了所有可能的情况。：开始一个循环，只要左边界不大于右边界，循环就会继续。：通过标准输入读取用户输入的整数，并将其存储在变量。：包含标准输入输出库，用于程序中的输入输出操作。：如果循环结束时没有找到目标值，打印这条消息。：如果找到目标值，打印其在数组中的下标。，则找到了目标值，打印下标并退出循环。在有序的数字里，查找某一个数字。，并初始化为1到30的整数。，用于存储用户输入的值。的长度，即元素的总数。作为二分查找的左边界。作为二分查找的右边界。
折半查找算法（BinarySearch）
深入挖掘，筑基为先；知其然，知其所以然。
01-30 6497
折半查找算法（BinarySearch)的文字描述、图示描述和代码描述。
算法刷题入门数据结构|二分查找
weixin_42575593的博客
12-11 3239
一.二分查找基础 1、二分查找介绍 二分查找(Binary search)也称折半查找，是一种效率较高的查找方法，时间复杂度。当对查数题目有时间复杂度要求是，首先就要考虑到二分查找。二分查找的思想很简单，属于分治策略的变种情况。但是，二分查找要求线性表中的记录必须是有序的集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0，所以必须采用...
C语言知识点精细详解——数据类型和变量【1】——进位计数制
qq_67611811的博客
04-19 1792
机器数数据类型预热必备知识点，数值在计算机中的存储，学习原反补码和编译器处理数据的必备知识。
在编译前与后调教C语言binary的一种方法
Blanchet的博客
01-31 463
在编译前与后调教C语言binary的一种方法
二叉查找树-BinarySearchTree-C语言实现
MyNuTh的博客
01-16 519
二叉查找树-BinarySearchTree 二叉查找树即二叉树的左子树的值都小于根节点的值，右子树的值都大于根节点的值。有几个显而易见的性质： 1.最左子节点为最小值； 2.最右子节点为最大值； 3.中序遍历得到从小到大的节点值序列。 实现主要分为binary_search_tree.h和binary_search_tree.c两个文件，在linux上已经跑通并做了简单的测试。 首先为binary_search_tree.h typedef struct treenode{ int val; st
c语言转换为binary
Ting_Yann的博客
09-06 845
c语言小程序转换为binary #include<stdio.h> int main(){ unsigned int x = 0xAF12 //hexadecimal unsigned int y = 0b0101010;//unsigned binary //printf the unsigned intger printf("%u" ,x); printf("%u", y); unsigned int z = 938271; printf("0x%x\n", z);
【C语言初阶】：二分查找算法（Binary Search）
HanSion.Z
03-29 5556
【引入问题】：假如现在我买了一件衣服，你非常好奇的问我多少钱，我说不超过500元。你还是很好奇，我让你接着猜，你才怎么猜呢？答案肯定是你每次猜最中间的数，第一次猜250，假如我有告诉你猜高了，你肯定会在小于250的部分继续除以2进行猜值，这就引入了二分查找的算法。*二分查找也叫折半查找，是一种效率比较高的查找方法。但是，二分查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。【查找过...
BinarySearch二分查找算法 C语言
qq_32923077的博客
04-07 1466
假设有一个人要我们猜0-99之间的一个数，那么最好的方法就是从0-99的中间数49开始猜。 如果要猜的数小于49，就猜24（0-48的中间数）；如果要猜的数大于49，就猜74（50-99的中间数）。 重复这个过程来缩小猜测的范围，直到猜出正确的数字。二分查找的工作方法就是如此。 基本概念： 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。 首先，假设表中元素是按升...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值