二叉排序树算法实例

1.#include <stdio.h>
#include <stdlib.h>
#include "BSTree.h"

/*  二叉树排序算法  */

struct Node
{
    BSTreeNode header;
    char v;
};

void printf_data(BSTreeNode* node)
{
    if( node != NULL )
    {
        printf("%c", ((struct Node*)node)->v);
    }
}

int compare_key(BSKey* k1, BSKey* k2)
{
    return (int)k1 - (int)k2;
}

int main(int argc, char *argv[])
{
    BSTree* tree = BSTree_Create();
    
    struct Node n1 = {{(BSKey*)1, NULL, NULL}, ‘A‘};
    struct Node n2 = {{(BSKey*)2, NULL, NULL}, ‘B‘};
    struct Node n3 = {{(BSKey*)3, NULL, NULL}, ‘C‘};
    struct Node n4 = {{(BSKey*)4, NULL, NULL}, ‘D‘};
    struct Node n5 = {{(BSKey*)5, NULL, NULL}, ‘E‘};
    struct Node n6 = {{(BSKey*)6, NULL, NULL}, ‘F‘};
    
    BSTree_Insert(tree, (BSTreeNode*)&n4, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n1, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n3, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n6, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n2, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n5, compare_key);
    
    printf("Height: %d\n", BSTree_Height(tree));
    printf("Degree: %d\n", BSTree_Degree(tree));
    printf("Count: %d\n", BSTree_Count(tree));
    printf("Search Key 5: %c\n", ((struct Node*)BSTree_Get(tree, (BSKey*)5, compare_key))->v);
    printf("Full Tree: \n");
    
    BSTree_Display(tree, printf_data, 4, ‘-‘);
    
    BSTree_Delete(tree, (BSKey*)4, compare_key);
    
    printf("After Delete Key 4: \n");
    printf("Height: %d\n", BSTree_Height(tree));
    printf("Degree: %d\n", BSTree_Degree(tree));
    printf("Count: %d\n", BSTree_Count(tree));
    printf("Full Tree: \n");
    
    BSTree_Display(tree, printf_data, 4, ‘-‘);
    
    BSTree_Clear(tree);
    
    printf("After Clear: \n");
    printf("Height: %d\n", BSTree_Height(tree));
    printf("Degree: %d\n", BSTree_Degree(tree));
    printf("Count: %d\n", BSTree_Count(tree));
    
    BSTree_Display(tree, printf_data, 4, ‘-‘);
    
    BSTree_Destroy(tree);
    
    return 0;
}

2.#ifndef _BSTREE_H_
#define _BSTREE_H_

typedef void BSTree;    
typedef void BSKey;        //关键字的类型

typedef struct _tag_BSTreeNode BSTreeNode;
/*  二叉排序来源于二分查找  */
struct _tag_BSTreeNode
{
    BSKey* key;            //关键字
    BSTreeNode* left;
    BSTreeNode* right;
};

typedef void (BSTree_Printf)(BSTreeNode*);
//定义一个比较函数
typedef int (BSTree_Compare)(BSKey*, BSKey*);

BSTree* BSTree_Create();

void BSTree_Destroy(BSTree* tree);

void BSTree_Clear(BSTree* tree);
//compare-->通过比较插入；BSTree_Compare函数比较指针；
int BSTree_Insert(BSTree* tree, BSTreeNode* node, BSTree_Compare* compare);

BSTreeNode* BSTree_Delete(BSTree* tree, BSKey* key, BSTree_Compare* compare);

BSTreeNode* BSTree_Get(BSTree* tree, BSKey* key, BSTree_Compare* compare);

BSTreeNode* BSTree_Root(BSTree* tree);

int BSTree_Height(BSTree* tree);

int BSTree_Count(BSTree* tree);

int BSTree_Degree(BSTree* tree);

void BSTree_Display(BSTree* tree, BSTree_Printf* pFunc, int gap, char div);

#endif

3.#include <stdio.h>
#include <malloc.h>
#include "BSTree.h"

typedef struct _tag_BSTree TBSTree;
struct _tag_BSTree
{
    int count;
    BSTreeNode* root;
};
//递归显示
static void recursive_display(BSTreeNode* node, BSTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        
        pFunc(node);
        
        printf("\n");
        
        if( (node->left != NULL) || (node->right != NULL) )
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}
//节点数
static int recursive_count(BSTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);
    }
    
    return ret;
}
//高度
static int recursive_height(BSTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        int lh = recursive_height(root->left);
        int rh = recursive_height(root->right);
        
        ret = ((lh > rh) ? lh : rh) + 1;
    }
    
    return ret;
}
//递归度
static int recursive_degree(BSTreeNode* root) // O(n)
{
    int ret = 0;
    
    if( root != NULL )
    {
        if( root->left != NULL )
        {
            ret++;
        }
        
        if( root->right != NULL )
        {
            ret++;
        }
        
        if( ret == 1 )
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);
            
            if( ret < ld )
            {
                ret = ld;
            }
            
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }
    
    return ret;
}
//insert  
static int recursive_insert(BSTreeNode* root, BSTreeNode* node, BSTree_Compare* compare)
{
    int ret = 1;
    //先进行比较
    int r = compare(node->key, root->key);
    
    if( r == 0 )
    {
        ret = 0;
    }
    //左节点
    else if( r < 0 )
    {
        if( root->left != NULL )
        {
            ret = recursive_insert(root->left, node, compare);
        }
        else
        {
            root->left = node;
        }
    }
    //右节点
    else if( r > 0 )
    {
        if( root->right != NULL )
        {
            ret = recursive_insert(root->right, node, compare);
        }
        else
        {
            root->right = node;
        }
    }
}
//递归查询
static BSTreeNode* recursive_get(BSTreeNode* root, BSKey* key, BSTree_Compare* compare)
{
    BSTreeNode* ret = NULL;
    
    if( root != NULL )
    {
        int r = compare(key, root->key);
        
        if( r == 0 )
        {
            ret = root;
        }
      //左查找
        else if( r < 0 )
        {
            ret = recursive_get(root->left, key, compare);
        }
      //右查找
        else if( r > 0 )
        {
            ret = recursive_get(root->right, key, compare);
        }
    }
    
    return ret;
}
//delete 节点
static BSTreeNode* delete_node(BSTreeNode** pRoot)
{
    BSTreeNode* ret = *pRoot;
    //判断是否在左右子树  三种情况 -->仅左右孩子  有两个孩子
    if( (*pRoot)->right == NULL )
    {
        *pRoot = (*pRoot)->left;
    }
    else if( (*pRoot)->left == NULL )
    {
        *pRoot = (*pRoot)->right;
    }
    else
    {
    //子树的子树
        BSTreeNode* g = *pRoot;
        BSTreeNode* c = (*pRoot)->left;
        
        while( c->right != NULL )
        {
            g = c;
            c = c->right;
        }
        
        if( g != *pRoot )
        {
            g->right = c->left;
        }
        else
        {
            g->left = c->left;
        }
      //
        c->left = (*pRoot)->left;
        c->right = (*pRoot)->right;
        
        *pRoot = c;
    }
    
    return ret;
}
//删除 之后还是一颗二叉树 pRoot指向指针指针
static BSTreeNode* recursive_delete(BSTreeNode** pRoot, BSKey* key, BSTree_Compare* compare)
{
    BSTreeNode* ret = NULL;
    //*pRoot根节点
    if( (pRoot != NULL) && (*pRoot != NULL) )
    {
      //首先根据根节点进行比较
        int r = compare(key, (*pRoot)->key);
        //删除根节点
        if( r == 0 )
        {
            ret = delete_node(pRoot);
        }
      //不然有左边子树
        else if( r < 0 )
        {
            ret = recursive_delete(&((*pRoot)->left), key, compare);
        }
      //否则
        else if( r > 0 )
        {
            ret = recursive_delete(&((*pRoot)->right), key, compare);
        }
    }
    
    return ret;
}
//创建一颗二叉树
BSTree* BSTree_Create() // O(1)
{
    TBSTree* ret = (TBSTree*)malloc(sizeof(TBSTree));
    
    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}
//销毁二叉树
void BSTree_Destroy(BSTree* tree) // O(1)
{
    free(tree);
}
//清除二叉树
void BSTree_Clear(BSTree* tree) // O(1)
{
    TBSTree* btree = (TBSTree*)tree;
    
    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}
//根据节点插入
int BSTree_Insert(BSTree* tree, BSTreeNode* node, BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = (btree != NULL) && (node != NULL) && (compare != NULL);
    
    if( ret )
    {
        node->left = NULL;
        node->right = NULL;
        
        if( btree->root == NULL )
        {
            btree->root = node;  
        }
        else
        {
            ret = recursive_insert(btree->root, node, compare);
        }
        
        if( ret )
        {
            btree->count++;
        }
    }
    
    return ret;
}
//通过关键字删除元素
BSTreeNode* BSTree_Delete(BSTree* tree, BSKey* key, BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    
    if( (btree != NULL) && (key != NULL) && (compare != NULL) )
    {
        ret = recursive_delete(&btree->root, key, compare);
        
        if( ret != NULL )
        {
            btree->count--;
        }
    }
    
    return ret;
}

BSTreeNode* BSTree_Get(BSTree* tree, BSKey* key, BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    
    if( (btree != NULL) && (key != NULL) && (compare != NULL) )
    {
        ret = recursive_get(btree->root, key, compare);
    }
    
    return ret;
}

BSTreeNode* BSTree_Root(BSTree* tree) // O(1)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    
    if( btree != NULL )
    {
        ret = btree->root;
    }
    
    return ret;
}

int BSTree_Height(BSTree* tree) // O(n)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    
    return ret;
}

int BSTree_Count(BSTree* tree) // O(1)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = btree->count;
    }
    
    return ret;
}

int BSTree_Degree(BSTree* tree) // O(n)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    
    return ret;
}

void BSTree_Display(BSTree* tree, BSTree_Printf* pFunc, int gap, char div) // O(n)
{
    TBSTree* btree = (TBSTree*)tree;
    
    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

时间： 2024-08-08 17:03:09

二叉排序树算法实例的相关文章

Floyd算法实例

~ 当k=0时,我们关注的是邻接矩阵的第0行和第0列,即顶点0的入边和出边: 考察矩阵中其他元素,如果元素D[i][j]向第0行和第0列的投影D[0][j]和D[i][0]都有值,就说明原图中从 i 到 j 存在一条经过顶点0的有向路径 i -> 0 -> j, 这样的路径包含的边数不会超过2,如果其权值小于D[i][j],则应用这个权值更新D[i][j],表明图中有向路径 i -> 0 -> j 相比原有路径更短. k=1.2时情况类似~ OK哒,哈哈~ Floyd算法实例,布布

二叉排序树算法

1: package cn.cqu.huang; 2: 3: class BiTree{ 4: //二叉树节点包含三个域 5: private int data; 6: private BiTree left; 7: private BiTree right; 8: 9: 10: public BiTree(int x){ 11: data = x; 12: } 13: 14: public void add(BiTree b){ 15: if(b.data<data){ 16: if(left

MATLAB工具箱及算法实例

核心函数: (1) function[pop]=initializega(num,bounds,eevalFN,eevalOps,options)--初始种群的生成函数 [输出参数] pop--生成的初始种群 [输入参数] num--种群中的个体数目bounds--代表变量的上下界的矩阵eevalFN--适应度函数eevalOps--传递给适应度函数的参数options--选择编码形式(浮点编码或是二进制编码)[precisionF_or_B],如precision--变量进行二进制编码时指定的

javascript常用经典算法实例详解

javascript常用经典算法实例详解 这篇文章主要介绍了javascript常用算法,结合实例形式较为详细的分析总结了JavaScript中常见的各种排序算法以及堆.栈.链表等数据结构的相关实现与使用技巧,需要的朋友可以参考下 本文实例讲述了javascript常用算法.分享给大家供大家参考,具体如下: 入门级算法-线性查找-时间复杂度O(n)--相当于算法界中的HelloWorld ? 1 2 3 4 5 6 7 8 9 10 //线性搜索(入门HelloWorld) //A为数组,x为要

算法实例_线性表 By:比方

算法实例_线性表 By:比方 什么是线性表? 从线性表的功能逻辑上来看,线性表就是由n(n>=0)个数据元素的排序组合,数据由x1,x2,x3,...,xn结构有序的顺序排列. 线性表的结构和特点 1.              仅有一个开始节点x1,没有直接前趋节点,有妾只有一个直接后续节点x2: 2.              仅有一个终结节点xn,仅有一个前趋节点xn-1; 3.              对于同一个线性表,其中没一个数据的元素,都必须具备相同的数据结构类型, 且没一个元素

php短网址算法实例代码分享

php实现的短网址算法,理论上支持1,073,741,824个短网址. 每个网址用6个字符代替,(6^32) 最多可以拥有1,073,741,824个短网址.当然,你还可以记录更详细的信息,如访问记录,创建时间等.如果真不够用了,还可以删掉很久不用的. function shorturl($input) { $base32 = array ( 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p

斐波那契递归和非递归俩种算法实例

package testcase; /** * * @decription \ \\_ .---(') o( )_-\_ 斐波那契递归和非递归俩种算法实例 * @author bjliuzezhou * @date 2016年2月23日 */ public class TypicalArithmetic_01 { public static void main(String[] args) { System.out.println(fn(6)); System.out.println(noRec

算法实例_链表结构 By:比方

前一章,我们说到了顺序表结构,而顺序表也存在一些的缺点. 在插入或者删除节点的时候,需要移动的数据比较大,如果顺序表结构比较大,有时候比较难以分配足够的连续存储空间,可能会导致内存分配失败,而导致无法存储. 而今天我们讲解的链表结构则可以很好的解决这个问题,链表的结构是一种动态存储分配的结构形式,可以根据需要动态申请所需的内存单元. 一．什么是链表结构? a)         我们用head来表示头节点. b)         数据部分保存的是存储的数据,地址地方指向下一个数据的起始部分,依次向

【机器学习】k-近邻算法以及算法实例

机器学习中常常要用到分类算法,在诸多的分类算法中有一种算法名为k-近邻算法,也称为kNN算法. 一.kNN算法的工作原理 二.适用情况 三.算法实例及讲解 ---1.收集数据 ---2.准备数据 ---3.设计算法分析数据 ---4.测试算法 一.kNN算法的工作原理 官方解释:存在一个样本数据集,也称作训练样本集,并且样本中每个数据都存在标签,即我们知道样本集中每一数据与所属分类的对应关系,输入没有标签的新数据后,将新数据的每个特征与样本集中的数据对应的特征进行比较,然后算法提取样本集中特征最