数据结构笔记-----二叉排序树和哈希表

最新推荐文章于 2023-10-01 10:41:33 发布
最新推荐文章于 2023-10-01 10:41:33 发布
阅读量572 收藏 1
点赞数
分类专栏： 嵌入式linux 文章标签： 数据结构 二叉排序树 哈希表 c语言 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1028951741/article/details/50943911
版权

二叉排序树


如何改进二分查找使其适应动态查找？


二分查找的过程


新的想法


二叉排序树






代码



BSTree.c

<strong><span style="font-size:18px;">#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;
}

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;
}

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;
}

static BSTreeNode* recursive_delete(BSTreeNode** pRoot, BSKey* key, BSTree_Compare* compare)
{
    BSTreeNode* ret = NULL;
    
    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);
    }
}</span></strong>

BSTree.h 

<strong><span style="font-size:18px;">#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);

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
</span></strong>

main.c 

<strong><span style="font-size:18px;">#include <stdio.h>
#include <stdlib.h>
#include "BSTree.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

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;
}</span></strong>

小结




哈希表及其实现

最常见的代码需求：


再论数组


一个常见的情形


解决方案







代码


Hash.c

<strong><span style="font-size:18px;">#include <stdio.h>
#include <malloc.h>
#include "Hash.h"
#include "BSTree.h"

typedef struct _tag_HashNode HashNode;
struct _tag_HashNode
{
    BSTreeNode header;
    HashValue* value;
};

void recursive_clear(BSTreeNode* node)
{
    if( node != NULL )
    {
        recursive_clear(node->left);
        recursive_clear(node->right);
        
        free(node);
    }
}

Hash* Hash_Create()
{
    return BSTree_Create();
}

void Hash_Destroy(Hash* hash)
{
    Hash_Clear(hash);
    BSTree_Destroy(hash);
}

void Hash_Clear(Hash* hash)
{
    recursive_clear(BSTree_Root(hash));
    BSTree_Clear(hash);
}

int Hash_Add(Hash* hash, HashKey* key, HashValue* value, Hash_Compare* compare)
{
    int ret = 0;
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    
    if( ret = (node != NULL) )
    {
        node->header.key = key;
        node->value = value;
        
        ret = BSTree_Insert(hash, (BSTreeNode*)node, compare);
        
        if( !ret )
        {
            free(node);
        }
    }
    
    return ret;
}

HashValue* Hash_Remove(Hash* hash, HashKey* key, Hash_Compare* compare)
{
    HashValue* ret = NULL;
    HashNode* node = (HashNode*)BSTree_Delete(hash, key, compare);
    
    if( node != NULL )
    {
        ret = node->value;
        
        free(node);
    }
    
    return ret;
}

HashValue* Hash_Get(Hash* hash, HashKey* key, Hash_Compare* compare)
{
    HashValue* ret = NULL;
    HashNode* node = (HashNode*)BSTree_Get(hash, key, compare);
    
    if( node != NULL )
    {
        ret = node->value;
    }
    
    return ret;
}

int Hash_Count(Hash* hash)
{
    return BSTree_Count(hash);
}</span></strong>

Hash.h 

<strong><span style="font-size:18px;">#ifndef _HASH_H_
#define _HASH_H_

typedef void Hash;
typedef void HashKey;
typedef void HashValue;

typedef int (Hash_Compare)(HashKey*, HashKey*);

Hash* Hash_Create();
void Hash_Destroy(Hash* hash);
void Hash_Clear(Hash* hash);
int Hash_Add(Hash* hash, HashKey* key, HashValue* value, Hash_Compare* compare);
HashValue* Hash_Remove (Hash* hash, HashKey* key, Hash_Compare* compare);
HashValue* Hash_Get(Hash* hash, HashKey* key, Hash_Compare* compare);
int Hash_Count(Hash* hash);


#endif</span></strong>

main.c 

<strong><span style="font-size:18px;">#include <stdio.h>
#include <stdlib.h>
#include "Hash.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Student
{
    char* id;
    char* name;
    int age;
};

int compare_id(HashKey* k1, HashKey* k2)
{
    return strcmp((char*)k1, (char*)k2);
}

int main(int argc, char *argv[]) 
{
    Hash* hash = Hash_Create();
    
    struct Student s1 = {"9001201", "Delphi", 30};
    struct Student s2 = {"0xABCDE", "Java", 20};
    struct Student s3 = {"koabc", "C++", 40};
    struct Student s4 = {"!@#$%^", "C#", 10};
    struct Student s5 = {"Python", "Python", 10};
    struct Student* ps = NULL;
    
    Hash_Add(hash, s1.id, &s1, compare_id);
    Hash_Add(hash, s2.id, &s2, compare_id);
    Hash_Add(hash, s3.id, &s3, compare_id);
    Hash_Add(hash, s4.id, &s4, compare_id);
    Hash_Add(hash, s5.id, &s5, compare_id);
    
    ps = Hash_Get(hash, "koabc", compare_id);
    
    printf("ID: %s\n", ps->id);
    printf("Name: %s\n", ps->name);
    printf("Age: %d\n", ps->age);
    
    Hash_Destroy(hash);
    
	return 0;
}</span></strong>


小结




整个数据结构总结


扩展学习


 更多品种的树


算法设计


下一步的学习


















数据结构——二叉排序树
Seven_Yang_C的博客
09-02 2164
二叉排序树（BST） 也称为二叉查找树。二叉排序树或者为空树，或者为非空树，当为非空树时，满足（递归定义）： 若左子树非空，则左子树上所有结点关键字值均小于根结点的关键字； 若右子树非空，则右子树上所有结点关键字值均大于根结点的关键字； 左子树、右子树本身也分别是一棵二叉排序树。 组织内存索引 二叉排序树是适用于内存储器的一种重要树形索引（常用红黑树、伸展树等以维持平衡） 外存常用B/B+数 中序遍历序列：1、2、3、4、5、7、8、10、16（依次递增） 左子树结点值<<<根..
算法数据结构学习笔记-C语言.zip
01-01
8. **散列表（哈希表）**：散列表是一种通过哈希函数将键映射到数组索引的数据结构，提供快速的查找、插入和删除操作。C语言中实现散列表需要理解和运用哈希函数及解决哈希冲突的方法。 9. **排序与查找算法**：在...
二叉搜索树和哈希表的总结
Stephen_curry_66的博客
05-06 394
Map的使用 public static void main(String[] args) { Map<Integer,String> map=new HashMap<>(); map.put(1,"hello"); map.put(2,"word"); map.put(3,"heheh"); ...
《数据结构》—— 二叉排序树
博樽
10-10 4882
二叉排序树的定义、查找、插入、构建、删除、查找效率分析。
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归...斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
数据结构看书笔记---lazyfennec整理精选
11-15
"数据结构看书笔记---lazyfennec整理精选"是一份由lazyfennec精心整理的数据结构学习资料，旨在帮助学习者深入理解并掌握这一领域的重要概念和算法。 笔记可能涵盖了以下几个关键知识点： 1. **数组**：数组是最...
2022王道考研-数据结构笔记.zip
最新发布
06-16
在实际应用中，往往需要结合多种数据结构来解决问题，例如，二叉搜索树结合哈希表可以提供高效查找和更新。 对于C/C++/JAVA/Python等编程语言，理解和熟练使用这些数据结构是成为优秀程序员的基础。C++和Java提供了...
数据结构（二叉排序树）
cbzhunian
05-11 802
二叉排序树：根节点的值一定大于左子树的值，一定小于右子树的值。 二叉排序树的建立，添加，删除，查找 #include<cstring> #include<algorithm> #include<iostream> #include<cstdio> #include<malloc.h> #include<queue> #i...
数据结构___二叉排序树
01-07
一、实验目的 （1）理解动态查找表的动态生成过程； （2）任意给出一组数（不少于10个），建立对应二叉排序树； （3）在二叉排序树基础上进行数据的查找实验； （4）对比观察同样数据不同排列顺序，建立的二叉排序树是否一样。 二、 实验内容 （1）定义二叉排序树的数据结构； （2）实现二叉排序树的插入算法与查找算法，并建立二叉排序树； （3）进行数据查找和建树过程的比较。
顺序查找,折半查找,二叉排序树,哈希表
07-03
实验：实现顺序查找，折半查找，二叉排序树，哈希表实验原理：
数据结构-----二叉排序树
热门推荐
m0_73633088的博客
10-01 1万+
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
【数据结构·考研】二叉搜索树的插入与删除
Jiawen9的博客
09-04 1875
建立一棵二叉搜索树 二叉搜索树的巨大优势就是：在平均情况下，能够在 O(logN) 的时间内完成搜索和插入元素。 递归版本： //插入值为key的结点（递归） TreeNode* insertIntoBST(Tree& t, int key) { if(t == NULL){ //找到插入目标 t = new TreeNode; t->val = key; return t; } if(key > t->
数据结构—二叉排序树
Shaun善逸的博客
06-22 426
二叉排序树 也叫二叉查找树（BST，Binary Search Tree）。 性质： 左子树结点值 < 根结点值 < 右子树结点值 左子树和右子树又各是一棵二叉排序树 中序遍历可得到一个递增序列 1、二叉排序树的查找 逻辑： 若树非空，目标值与根节点的值比较； 若相等，则查找成功； 若小于根节点，则在左子树上查找，否则在右子树上查找。 代码： typedef struct BSTNode{ int key; struct *BSTNode lchild, rchild; }BSTNode,
数据结构_二叉排序树
ashmoc的博客
09-10 87
树 ( Tree ) 是 n ( n ≥ 0) 个结点的有限集。n = 0 时称为空树。 在任意一颗非空树中： 有且仅有一个特定的称为 根 ( Root) 的结点 当 n > 1 时，其余结点可分为 m ( m > 0) 个互不相交的有限集 T₁ 、 T₂ 、 …… 、Tₘ ，其中每个集合本身又是一棵树，并且称为根的子树 ( SubTree ) 。 当 n > 0 时根节点是唯一的，不可能存在多个根结点。 m > 0 时，子树的个数没有限制，但它们一定是互不相交的。 ...
JAVA算法分析读书笔记 - 数据结构深入理解
6. 高级数据结构：探索散列表、哈希函数、红黑树、B-树等更高级的数据结构。 7. 算法设计技巧：学习并实践分治策略、动态规划、贪心算法等算法设计方法。 8. 应用案例：通过实际应用案例来加深对理论知识的理解，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值