2021-10-13-《C#数据结构与算法》-学习笔记-P53-P58 哈希表&数据结构总结

最新推荐文章于 2024-11-07 23:35:47 发布
最新推荐文章于 2024-11-07 23:35:47 发布
阅读量134 收藏
点赞数
分类专栏： 《C#数据结构与算法》 文章标签： 数据结构 算法 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49079904/article/details/120745782
版权
这篇学习笔记详细介绍了哈希表的概念，包括哈希函数设计、冲突解决、添加删除包含操作，并通过C#实现哈希表集合和字典。此外，还对比了哈希表与红黑树在实现集合和字典时的效率，并总结了动态数组、链表、有序数组、二分查找树、红黑树和哈希表等数据结构。
摘要由CSDN通过智能技术生成

总结

1.视频资源P53-P58：
https://www.bilibili.com/video/BV1gE41157pC?p=8&spm_id_from=pageDriver
2.学习内容：
1）哈希表 P53；
2）哈希冲突处理 P54；
3）哈希表添加、删除、包含 P55；
4）基于哈希表实现集合 P56；
5）基于哈希表实现字典 P57；
6）数据结构总结 P58。
2021/11/05回溯
1）根据伪代码编写哈希表类；

具体内容

P53 哈希表
1、哈希表思想；
2、哈希表中将不同类型键对应索引的方法；
3、哈希函数的设计，三个条件的满足；
4、C#中的哈希函数。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P54 哈希冲突处理
1、基于拉链法的哈希表；
2、创建基于拉链法的哈希表类。

在这里插入图片描述
在这里插入图片描述

P55 哈希表添加、删除、包含
1、实现哈希表添加、删除、包含方法。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class HashST1<Key>
    {
        //链表数组
        private Linkedlist1<Key>[] hashtable;
        //数组容量
        private int M;
        //数组长度
        private int N;

        public HashST1(int M)
        {
            this.M = M;
            N = 0;
            hashtable = new Linkedlist1<Key>[M];

            //对每一个数组索引开辟一个链表
            for (int i = 0; i < M; i++)
            {
                hashtable[i] = new Linkedlist1<Key>();
            }
        }

        public HashST1()
        {
            M = 97;
            N = 0;
            hashtable = new Linkedlist1<Key>[97];

            //对每一个数组索引开辟一个链表
            for (int i = 0; i < M; i++)
            {
                hashtable[i] = new Linkedlist1<Key>();
            }
        }

        public int Count
        {
            get { return N; }
        }

        public bool IsEmpty
        {
            get { return N == 0; }
        }

        //对整数取余并保证为正数
        private int Hash(Key key)
        {
            return (key.GetHashCode() & 0x7fffffff) % M;
        }

        public void Add(Key key)
        {
            Linkedlist1<Key> list = hashtable[Hash(key)];
            if (list.Contains(key))
            {
                return;
            }
            else
            {
                list.InsertFirst(key);
                N++;
            }
        }

        public void Remove(Key key)
        {
            Linkedlist1<Key> list = hashtable[Hash(key)];
            if (list.Contains(key))
            {
                list.Remove(key);
                N--;
            }
            else
            {
                return;
            }
        }

        public bool Contains(Key key)
        {
            Linkedlist1<Key> list = hashtable[Hash(key)];
            return list.Contains(key);
        }
    }
}

P56 基于哈希表实现集合
1、创建哈希表集合类；
2、比较基于红黑树与哈希表实现集合的运行效率；
3、C#中的哈希表集合类；
4、解析哈希表无法取代红黑树的原因。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class HashST1Set<Key>:ISet<Key>
    {
        private HashST1<Key> hashST1Set;

        public HashST1Set(int M)
        {
            hashST1Set = new HashST1<Key>(M);
        }
        public HashST1Set()
        {
            hashST1Set = new HashST1<Key>();
        }

        public int Count { get { return hashST1Set.Count; } }

        public bool IsEmpty { get { return hashST1Set.IsEmpty; } }

        public void Add(Key key)
        {
            hashST1Set.Add(key);
        }

        public bool Contains(Key key)
        {
            return hashST1Set.Contains(key);
        }

        public void Remove(Key key)
        {
            hashST1Set.Remove(key);
        }
    }
}

P57 基于哈希表实现字典
1、创建适用于字典的哈希表类；
2、创建哈希表字典类；
3、比较基于红黑树与哈希表实现字典的运行效率；
4、C#中的哈希表字典类。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class HashST2<Key,Value> where Key:IComparable<Key>
    {
        //链表数组
        private Linkedlist3<Key, Value>[] hashtable;
        //数组容量
        private int M;
        //数组长度
        private int N;

        public HashST2(int M)
        {
            this.M = M;
            N = 0;
            hashtable = new Linkedlist3<Key, Value>[M];

            //对每一个数组索引开辟一个链表
            for (int i = 0; i < M; i++)
            {
                hashtable[i] = new Linkedlist3<Key, Value>();
            }
        }

        public HashST2()
        {
            M = 97;
            N = 0;
            hashtable = new Linkedlist3<Key, Value>[97];

            //对每一个数组索引开辟一个链表
            for (int i = 0; i < M; i++)
            {
                hashtable[i] = new Linkedlist3<Key, Value>();
            }
        }

        public int Count
        {
            get { return N; }
        }

        public bool IsEmpty
        {
            get { return N == 0; }
        }

        //对整数取余并保证为正数
        private int Hash(Key key)
        {
            return (key.GetHashCode() & 0x7fffffff) % M;
        }

        public void Add(Key key, Value value)
        {
            Linkedlist3<Key, Value> list = hashtable[Hash(key)];
            if (list.ContainsKey(key))
            {
                list.Set(key, value);
            }
            else
            {
                list.Insert(key,value);
                N++;
            }
        }

        public void Remove(Key key)
        {
            Linkedlist3<Key, Value> list = hashtable[Hash(key)];
            if (list.ContainsKey(key))
            {
                list.Remove(key);
                N--;
            }
            else
            {
                return;
            }
        }

        public bool ContainsKey(Key key)
        {
            Linkedlist3<Key,Value> list = hashtable[Hash(key)];
            return list.ContainsKey(key);
        }

        public Value Get(Key key)
        {
            Linkedlist3<Key, Value> list = hashtable[Hash(key)];
            return list.Get(key);
        }

        public void Set(Key key,Value newValue)
        {
            Linkedlist3<Key, Value> list = hashtable[Hash(key)];
            list.Set(key,newValue);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class HashST2Dictionary<Key,Value>:IDictionary<Key,Value> where Key:IComparable<Key>
    {
        private HashST2<Key, Value> hashST2Dictionary;

        public int Count { get { return hashST2Dictionary.Count; } }

        public bool IsEmpty { get { return hashST2Dictionary.IsEmpty; } }

        public HashST2Dictionary(int M)
        {
            hashST2Dictionary = new HashST2<Key, Value>(M);
        }

        public HashST2Dictionary()
        {
            hashST2Dictionary = new HashST2<Key, Value>();
        }

        public void Remove(Key key)
        {
            hashST2Dictionary.Remove(key);
        }

        public void Add(Key key, Value value)
        {
            hashST2Dictionary.Add(key, value);
        }

        public bool ContainsKey(Key key)
        {
            return hashST2Dictionary.ContainsKey(key);
        }

        public Value Get(Key key)
        {
            return hashST2Dictionary.Get(key);
        }

        public void Set(Key key, Value newValue)
        {
            hashST2Dictionary.Set(key, newValue);
        }
    }
}

P58 数据结构的总结
1、动态数组；
2、链表；
3、有序数组；
4、二分查找树；
5、红黑树；
6、哈希表。

在这里插入图片描述

Joy_ou悠
关注
专栏目录
数据结构与算法（C#）-数据结构
xubufanzhou的博客
04-04 595
数据结构（C#）学习笔记
C#数据结构与算法学习笔记 哈希表
Mr_Tfos的博客
05-27 127
1.哈希函数的设计 2.哈希冲突处理 3.哈希表添加、删除、包含
C#数据结构与算法学习笔记 基于哈希表实现集合、映射
Mr_Tfos的博客
05-27 193
基于哈希表实现集合 class HashST1Set<Key> : ISet<Key> { private HashST1<Key> hashST1; public int Count { get { return hashST1.Count; } } public bool IsEmpty { get { return hashST1.IsEmpty; } } public HashS
数据结构—笔记整理—初识数据结构
热门推荐
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
数据结构笔记-----二叉排序树和哈希表
碧海蓝天观潮涌
03-21 572
二叉排序树 1 如何改进二分查找使其适应动态查找？ 2 二分查找的过程 3 新的想法 4 二叉排序树 5 6 7 8 代码 9
（超简单、超易懂、超详细）算法精讲(五十)： Boyer-Moore算法
Malex2024的博客
06-25 713
Boyer-Moore算法是一种用于串匹配的字符串查找算法，能够在最坏情况下以线性时间复杂度进行匹配。它通过在模式串中的字符比较中利用已匹配的信息，从而实现快速的匹配。Boyer-Moore算法的主要思想是从模式串的末尾开始向前匹配，将模式串与目标串逐个字符进行比较，并根据比较结果进行跳跃。具体来说，算法分为两个阶段：预处理阶段和匹配阶段。在预处理阶段，算法预先计算出每个字符在模式串中出现的最右位置，并根据这些信息生成两个跳跃表：坏字符规则表和好后缀规则表。
【Unity&C#】集合数据结构都有哪些?
awoodid的博客
01-19 1007
本文主要讨论：List（列表）,Dictionary（字典） ,Queue（队列） ,Stack（栈），HashSet(唯一集合),LinkedList（双向链表），BitArray（位数组），SortedSet（排序集合），ObservableCollection（可观察到的集合（机翻），我喜欢称为可观集合 ）， Queue（队列），ConcurrentDictionary（多线程字典（机翻是并发字典 ）），Immutable Collections（ 不可变的集合） 。。。。
【算法与数据结构】链表、哈希表、栈和队列、二叉树（笔记二）
晚安的博客
02-23 1553
结点拥有的子树个数称为结点的度，比如下图中结点3和结点4的度分别为3和2。对于树而言，树的度是结点最大的度，下面这棵树的度为4（结点1的度）。二叉树是指树的度最大为2的树。满二叉树：如果一棵树只有度为0和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。如下图所示，这是一棵满二叉树。这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。完全二叉树：在完全二叉树中，除了最底层节点可能没有填满以外，其余每层节点数量都达到最大值，并且最下面一层节点都集中在该层的最左边若干位置。
【数据结构】C# 实现常用数据结构总结
好学若饥，谦卑若愚。
02-02 3953
自行整理的C#常见数据结构笔记。
C#数据结构用于学习交流
05-22
最后，"C#数据结构用于学习交流"这个资源可能包含了课程笔记、代码示例、练习题和解决方案，这些都是提升你技能的有效工具。通过参与学习交流，你可以与他人分享经验，解答疑惑，进一步提高自己的编程能力。 总之，...
数据结构_C#版_高清_非扫描
12-31
"数据结构_C#版_高清_非扫描"这本书正是为C#程序员提供了一个深入学习数据结构的平台，其高质量的非扫描格式使得内容清晰易读，且可编辑的文字方便了学习者进行笔记和注解。 首先，书中可能涵盖了基本的数据结构...
C#语言实现数据结构与算法学习资源
1. 学习笔记：总结了数据结构与算法的基本概念、性质和应用场景。 2. 编程实现：提供了用C#语言实现各种数据结构和算法的示例代码，以及可能的测试用例。 3. 练习题与答案：设计了针对不同数据结构和算法的练习题目...
《数据结构与算法》二叉树基础OJ练习
2301_79722165的博客
11-05 246
学习了二叉树之后，来做点关于二叉树的基础题
【算法与数据结构】【链表篇】【题1-题5】
handsomethefirst的博客
11-07 594
题目：输入一个链表的头结点，从尾到头反过来打印出每个节点的值。思路：要反过来打印，首先需要遍历，那么从先遍历的节点后打印，典型的后进先出，符合栈的结构。
数据结构(C语言版)-1.线性表
yang_pi_pi的博客
11-07 849
胡元义，黑新宏 数据结构教程-》 第2章 线性表
【初阶数据结构篇】链式结构二叉树（二叉链）的实现（感受递归暴力美学）
braveact的博客
11-04 1217
按照规则，⼆叉树的遍历有：前序/中序/后序的递归结构遍历：1）前序遍历(Preorder Traversal 亦称先序遍历)：访问根结点的操作发⽣在遍历其左右⼦树之前访问顺序为：根结点、左⼦树、右⼦树2）中序遍历(Inorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之中（间）访问顺序为：左⼦树、根结点、右⼦树3）后序遍历(Postorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之后访问顺序为：左⼦树、右⼦树、根结点。
数据结构C语言描述2(图文结合)--有头单链表，无头单链表(两种方法)，链表反转、有序链表构建、排序等操作，考研可看
最新发布
weixin_74085818的博客
11-07 748
链表由一系列不必存在内存中连续的空间的结构组成；每一个结构都有包含元素的`数据域`和指向下一个节点的`指针域`，指针域存储指向下一个节点的指针，最后一个元素的指针指向为`NULL`。
数据结构计算二叉树节点的个数
qq_45153375的博客
11-07 201
因此，这棵树中度为0的节点数 ( n_0 = 4 )，度为1的节点数 ( n_1 = 3 )。因此，这棵树中度为0的节点数 ( n_0 = 6 )，度为2的节点数 ( n_2 = 5 )。因此，这棵树的总节点数是 18，度为2的节点数 ( n_2 = 7 )。以下是几道练习题帮助理解如何计算度为1和度为0的节点数量。
数据结构 | 第四章 | 栈和队列
ZJC744575的博客
11-07 190
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。LIFO（Last In First Out）的原则。：栈的插入操作叫做进栈/压栈/入栈，：栈的删除操作叫做出栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值