数据结构-第五章 散列

最新推荐文章于 2024-07-06 22:34:06 发布
最新推荐文章于 2024-07-06 22:34:06 发布
阅读量978 收藏 7
点赞数 1
分类专栏： 数据结构课程笔记 文章标签： 数据结构 哈希算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44202160/article/details/122996159
版权

Hashing

1. 散列函数

  1. 散列表(Hash function)
    • Address = hash(key)
  2. BT值用来标识文件的唯一性，校验值(官方会提供文件的标识值，用同样的算法来计算哈希值，如果不同，则这个文件已经发生过修改)
  3. 常用的哈希函数:奇偶校验法
  4. Eg.如果发生散列函数计算结果冲突(1 = 1)的时候，会使用一些方法来处理所带来的问题(散列表的常数复杂度只在不发生冲突的情况下，在发生冲突的情况下算法复杂度显然不为常数)

1.1. 散列函数的应用

  1. 通过添加散列函数来加快线性列表的读写速度。
  2. 散列函数的复杂度理论上能够到达常数级别复杂度。
    • Sequention search 线性查找: O(n)，显然在此情况下我们认为访问散列表的每一个位置的数据的概率是均等的。
    • Binary search: O(log2n)
    • hashing method: O©
      • Address=hash(key) also called : name-address function(名称-地址映射)

1.2. 散列函数

1.2.1. 如何寻找合适的散列函数

  1. Find a proper hash function How to solve a collision Select a suitable load factor α.(寻找合适的hash函数如何解决冲突选择合适的负载因子α)
  2. α=n/b
    • n is number of elements in the hash table b is the number of buckets in the hash table
    • α > 1 碰撞频率大
    • α < 1 碰撞频率小

1.2.2. 散列函数(1):取余法

  1. 大小通常取最大质数，避免造成散列中存在始终未用到的部分。

1.2.3. 散列函数(2):平方取中法

  1. 先进行原来的数据进行平方，然后选取中间的合适部分。
  2. 对于一个值，按照某一进制下进行处理，处理后选择其中合适的中间部分。(类字符串进行存取)

1.2.4. 散列函数(3):乘法杂凑函数

  1. %1是留下小数部分

1.2.5. 散列函数(4):针对字符串-1

  1. to add up the ASCII( or Unicode ) value of the characters in the string. 把字符串中的每一个字符的ASCII值或者Unicode值相加
public static int hash( String Key, int tableSize ) {
    int hashVal = 0;
    for( int i = 0; i < Key.length( ); i++ )
        hashVal += Key.charAt( i );
    return hashVal % tableSize;
}
  1. Suppose TableSize = 10007, Suppose all the keys are eight or fewer characters long, 8*127=1016 hash function typically can only assume value between 0~1016 引起浪费(字符串过短会导致浪费)

1.2.6. 散列函数(5):针对字符串-2

  1. 相当于对原来常数级的事情，添加一个常数来形成多项式。

1.2.7. 其他散列函数(考试无要求)

  1. EL-hash

1.3. 如何解决散列表冲突问题

碰撞的两个(或多个)关键码称为同义词, 即H(k1)=H(k2),k1不等于k2

1.3.1. 解决冲突方案(1):linear Probing(线性探测法)

  1. If hash(key)= d and the bucket is already occupied then we will examine successive buckets d+1, d+2,……m-1, 0, 1, 2, ……d-1, in the array(如何key的哈希值是d，并且d对应的位置已经被占据，然后我们会按照线性顺序向后成环形查找)

  2. 散列表已经满了之后，算法复杂度比较高，需要遍历整个散列表

  3. 例一


  1. 计算例一中的平均成功访问次数

  1. 例二

  1. 线性表示法的弊端:堆积问题

  1. 不能直接删除线性表中的数据，应该是标记上删除标记

1.3.2. 解决冲突方法(2):二次探测法(Quadratic probing)

  1. If hash(k)= d and the bucket is already occupied then we will examine successive buckets d + 1, d + 22, d + 32 ……, in the array
  2. 放置hash值相同的情况下导致严重的堆积情况。

1.3.3. 解决冲突方法(3):双散列哈希(Double Hashing)

  1. If hash1(k)= d and the bucket is already occupied then we will counting hash2(k) = c, examine successive buckets d+c, d+2c, d+3c……，in the array(如果k的第一哈希值为d，而这个对应的格子已经被占用则我们继续计算k的第二哈希值，然后检查d+c…)

  1. 第一个散列函数发生冲突，那么使用第二个散列函数来放置，如果再次冲突则进行相应探测。

  2. 再散列(进行扩容)

  1. 尽量保证表项数>表的70%，也就是意味着如果不满足，就需要进行再散列。

  1. 再散列的实现
private void rehash(){
    HashEntry [] oldArray = array ;
    allocateArray(nextPrime(2*oldArray.length));
    currentSize = 0;
    for( int i = 0;i < oldArray.length;i++ )
        if(oldArray[i] != null && oldArray[i].isActive)
            insert(oldArray[i].Element);
}

1.3.4. 解决冲突方法(4):分离链接法(Separate Chaining)

  1. 使用每个位置对应线性表解决这个问题

  1. 避免了出现向下进行顺延的情况。

1.4. 散列表的实现

  1. Assume that each element to be stored in the hash table is of type E and has a field key of type k.(我们假设存储在散列表中的每一元素的类型是E，并且有一个类型为k的关键码)
  2. the hash table is implemented using two arrays: ht and empty.(散列表的实现使用了两个数组，一个是ht，另一个是empty)
  3. empty[i] is true iff ht[i] does not have an element in it. It is defined for the deletion operation(ht[t]中含有关键码当且仅当empty[i]是true。)

1.4.1. 散列表的c++实现

template<class E,class K>
class HashTable{ 
    public:
        HashTable(int divisor =11);
        ~HashTable(){
            delete[]ht;
            delete []empty;
        }
        bool Search(const K&k ,E& e)const; 
        HashTable<E,K>&Insert(const E&e);
    private:
        int hSearch(const K& k)const;
        int D;//hash function divisor
        E *ht ; //hash table array
        bool *empty ; //1D array
};

1.4.2. 线性探测法的c++实现

//hashtable的构造方法
template<class E,class K>//E和K需要被实例化后，这个类才能被调用。
HashTable<E,K>::HashTable(int divisor){
    D = divisor;
    ht = new E[D];
    empty= new bool[D];
    for(int i=0;i<D;i++)
        empty[i] = true;
}

template<class E,class K>
int HashTable<E,K>::hSearch(const K&k)const {
    int i= % D;//home bucket
    int j= i ; //start at home bucket
    do {
        if(empty[j] || ht[j]==k) return j;//fit
        j=(j+1)%D; //next bucket
    } while(j!= i);  //returned to home?是否循环完成一遍
    return j; //table full;
}

//参数进行引用K&k
template<class E,class K>
bool HashTable<E,K>::Search(const K&k,E&e)const{
    //put element that matches k in e.
    //return false if no match.
    int b= hSearch(k);
    if(empty[b]||Hash(ht[b])!=k)return false;
    e=ht[b];
    return true;
}

template<class E,class K>
HashTable<E,K>& HashTable<E,K>::Insert(const E& e) {
     K k=Hash(e);//extract key
     int b=hSearch(k);
     if(empty[b]){
        empty[b]=false;
        ht[b]=e;
        return *this;
    }
    throw NoMem();  //table full
}

1.4.3. 散列表的java实现(二次探测法)

public interface Hashable {
    int hash(int tableSize);
}
class HashEntry {
    Hashable element;
    boolean isActive;
    public HashEntry(Hashable e){this(e, true);
    }
    public HashEntry(Hashable e, boolean i) {
        this.element = e;
        this.isActive = i;
    }
}
public class QuadraticProbingHashTable {   
    public QuadraticProbingHashable()
    public QuadraticProbingHashable(int size)
    public void makeEmpty( )  
    
    public Hashable find(Hashable x)
    public void insert(Hashable x)
    public void remove(Hashable x)  
    
    public static int hash(String key, int tableSize)
    private static final int DEFAULT_TABLE_SIZE = 11;
    
    protected HashEntry [ ] array; private int currentSize;
    private void allocateArray(int arraySize )
    private boolean isActive( int currentPos )
    private int findPos( Hashable x )  
    private void rehash( )//需要扩大hash表大小的时候，再哈希
    private static int nextPrime( int n ) 
    private static boolean isPrime( int n )
}

//构造方法
public QuadraticProbingHashTable( ) {
    this( DEFAULT_TABLE_SIZE );
}
public QuadraticProbingHashTable( int size ) {
    allocateArray( size );
    makeEmpty( );
}
//其他方法
private void allocateArray(int arraySize){
    array = new HashEntry[arraySize];
}
//清空哈希表
public void makeEmpty() {
    currentSize = 0;
    for( int i = 0; i < array.length; i++ )
        array[ i ] = null;
}
//查找哈希表元素
public Hashable find(Hashable x) {
    int currentPos = findPos(x);
    return isActive(currentPos)?array[currentPos].element:null;
}
private int findPos(Hashable x) {
    int collisionNum = 0;
    int currentPos = x.hash(array.length); 
    while(array[currentPos] != null && !array[currentPos].element.equals(x)) {
        currentPos += 2*collisionNum – 1;//二次探测法 n2 - (n-1)2= 2n-1
        if(currentPos >= array.length)
            currentPos -= array.length;
    }//如果已经放满，并且要找的值不在里面会进入死循环
    return currentPos;
}
private boolean isActive( int currentPos )  {
    return array[currentPos]!=null && array[ currentPos ].isActive;
}
public void insert(Hashable x) {
    int currentPos = findPos(x);
    if(isActive(currentPos))
        return;
    array[currentPos] = new HashEntry( x, true );
    if( ++currentSize > array.length/2)
        rehash();
}
public final void remove(Hashable x) {  
    int currentPos = findPos(x);
    if(isActive(currentPos))
        array[currentPos].isActive = false;
}

1.4.4. 散链表的java实现(分离连接法)

public class SeparateChainingHashTable  {  
    public SeparateChainingHashTable( ) 
    public SeparateChainingHashTable( int size )
    public void insert( Hashable x )
    public void remove( Hashable x )
    public Hashable find( Hashable x )  
    public void makeEmpty( )
    public static int hash( String key, int tableSize )  
    
    private static final int DEFAULT_TABLE_SIZE = 101;
    private LinkedList [] theLists;
    private static int nextPrime( int n ) 
    private static boolean isPrime( int n ) 
}

public interface Hashable{
    int hash( int tableSize );
}
public class Employee implements Hashable { 
    public int hash( int tableSize ) { 
        return SeparateChainingHashTable.hash( name, tableSize );
    }
    public boolean equals( object rhs ) { 
        return name.equals( ( Employee) rhs ).name );
    }
    
    private String name;
    private double salary;
    private int seniority;
}

public SeparateChainingHashTable()  {
    this( DEFAULT_TABLE_SIZE );
}
public SeparateChainingHashTable(int size) {
    theLists = new LinkedList[ nextPrime( size ) ];
    for( int i = 0; i < theLists.length; i++ ) theLists[ i ] = new LinkedList( );
}
public void makeEmpty( )  {
    for( int i = 0; i < theLists.length; i++ )
    theLists[ i ].makeEmpty( );
}
public void remove( Hashable x ){
    theLists[ x.hash( theLists.length ) ].remove( x );
}
public Hashable find( Hashable x ) {
    return ( Hashable ) theLists[ x.hash( theLists.length ) ]. Find( x ). Retrieve( );
}
public void insert( Hashable x )  {  
    LinkedList whichList = theLists[ x.hash( theLists.length ) ];
    LinkedListItr itr = whichList.find( x );
    if( itr.isPastEnd( ) )
        whichList.insert( x, whichList.zeroth( ) );
}
SpriCoder
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
散列函数（哈希函数，Hash Function）
ywok526的专栏
08-13 2万+
说明          散列的概念属于查找，它不以关键字的比较为基本操作，采用直接寻址技术。在理想情况下，查找的期望时间为O(1)。 简单的说，hash函数就是把任意长的输入字符串变化成固定长的输出字符串的一种函数。输出字符串的长度称为hash函数的位数。（下图来源于维基百科） 散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来，比如我们自定义密码的存储。 一句话：散
数据结构第五篇——栈和队列
qq_34028001的博客
08-02 484
目录 前言 一、栈的定义和特点 二、栈的逻辑结构以及基本操作 2.1 用抽象数据类型来定义栈的数据结构 2.2 顺序栈的定义及其特点 2.3 顺序存储结构对栈基本操作的实现 2.4 链栈的定义及其特点 2.5 链式存储结构对栈基本操作的实现 三、队列的定义和特点 四、队列的逻辑结构以及基本操作 4.1 用抽象数据类型来定义队列的数据结构 4.2顺序队列的定义及其特点 4.3顺序存储结构对队列基本操作的实现 4.4 链式队列的定义及其特点 4.5 链式存储结构对队列基本操..
常见数据类型的散列函数
qq_45666842的博客
01-08 1365
常见数据类型散列函数的简介
【数据结构--散列函数】
Lyao_Boker的博客
01-23 8361
散列函数的设计散列查找的基本思想散列函数的设计原则三种常见的散列函数1. 直接定址法2. 除留余数法3. 平方取中法处理冲突的方法1. 开放定址法2. 拉链法(链地址法) 散列查找的基本思想 在记录的存储位置和它的关键码之间建立一个确定的对应关系H，使得每个关键码key和唯一的存储位置H(key)相对应。 存储记录时，根据这个对应关系找到关键码的映射地址，并按此地址存储该记录；查找记录时，根据这个对应关系找到待查找关键码的映射地址，并按此地址访问该记录。 采用散列技术将记录存储在一块连续的存储空间中，这块连
密码学一:哈希函数 散列函数是什么 SHA-256原理 哈希碰撞
tenc1239的博客
10-15 2929
需要注意的是，随着计算能力的增强，一些早期的散列函数已经不再被视为安全，因此在选择散列函数时要谨慎，并考虑使用最新的、被广泛认可为安全的算法。虽然SHA-256生成的散列值是256位，但它在内部使用更大的数据块进行处理，这是因为SHA-256算法的设计要求。因此，SHA-256之所以要求输入数据的大小是512位的倍数，是因为它是基于512位数据块的处理算法，而最终的输出是256位。理论上，输入数据可以是无穷大的，但在实际应用中，这种情况是不可能的，因为计算机的内存和处理能力是有限的。
散列（Hash）基础知识
wangxiuyinde的博客
04-10 4338
一、散列的基本概念         散列方法的主要思想是根据结点的关键码值来确定其存储地址：以关键码值K为自变量，通过一定的函数关系h(K)(称为散列函数)，计算出对应的函数值来，把这个值解释为结点的存储地址，将结点存入到此存储单元中。检索时，用同样的方法计算地址，然后到相应的单元里去取要找的结点。通过散列方法可以对结点进行快速检索。散列（hash，也称“哈希”）是一种重要的存储方式，也是一种常
散列的基本概念
热门推荐
Shine__Wong的博客
10-04 1万+
散列的基本概念 什么是散列？为什么需要散列？ 散列是一种思想。与已经学过的其他数据结构相比较，向量是采用循秩访问(call by rank)的访问方式，列表是采用循位置访问(call by position)的访问方式，二叉搜索树是采用循关键码访问(call by key)的访问方式，散列与他们都不一样，是采用循值访问(call by value)的访问方式。 举个例子，你现在身处同济大学嘉定...
数据结构（五）——队列
qq_38181811的博客
03-14 228
相对于栈，队列（queue）是另外一种特殊的线性表。队列的逻辑设计是，删除运算限定在表的一端进行，插入运算则被限定在表的另一端进行。约定将允许插入的一端称为队尾（Rear），删除的那一端称为队首（Front）。这样的逻辑设计，就其实是现实生活里的排队嘛。因此，队列是先进先出表（First In Frist Out，FIFO）。 队列同样有顺式结构和链式结构（一种逻辑结构的两种物理结构）。顺式的长度...
数据结构作业：第9章作业题目.docx
12-14
本资源是一个数据结构作业的第9章作业题目，涵盖了数据结构中的查找方法、散列法、链表结构等知识点。下面是对该资源中涉及到的知识点的详细说明： 1. 查找方法：查找方法是数据结构中的一种基本操作，它指的是在一...
数据结构作业：第9章作业答案.docx
12-18
本资源摘要信息中，我们将对数据结构第9章作业答案进行详细的解释和分析，该答案涵盖了查找、散列、链表、顺序查找、折半查找、二分查找、哈希表、冲突解决等数据结构相关的知识点。 一、查找 查找是数据结构中的...
数据结构第0章1
08-08
课程的重点在于理解和掌握基本数据结构，如数组、顺序表、多项式、字符串、链表、栈、队列、优先级队列、广义表、树、森林、二叉树、堆、集合、图、搜索结构、索引结构和散列结构。学生需要学习这些数据结构的类定义...
西南交通大学-zhy-数据结构第5次作业.zip
12-22
数据结构;赵宏宇;一、查找 1. 算法设计题 ：已知n元顺序表a0, a1, … , an-1按关键字递增有序存储。给定关键字值key，编写算法用对分查找求下标i，满足ai-1且aikey。 2. 编程题：输入n个两两互不相等的整数，以...
数据结构第1章31
08-08
数据结构是计算机科学中一门核心的课程，它主要研究如何有效地组织和管理数据，以便于数据的存取和处理。在数据结构中，我们关注的重点是数据的逻辑结构、存储结构以及在这些结构上执行的基本操作。 1. **数据的...
散列函數（Hash Function）
weixin_40191861的博客
07-14 957
（英語：）又称，是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该将数据打乱混合，重新创建一个叫做（，，，或）的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。好的散列函数在输入域中很少出现散列冲突。在和中，不抑制冲突来区别数据，会使得数据库记录更难找到。如今，雜湊演算法也被用來加密存在資料庫中的（password）字串，由於雜湊演算法所計算出來的具有（無法逆向演算回原本的數值）的性質，因此可有效的保護密碼。
2021-05-28
wxw1437201626的博客
05-28 1057
什么是散列表？ 散列表 散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。 散列函数 散列函数，顾名思义，它是一个函数。如果把它定义成 hash(key) ，其中 key 表示元素的键值，则 hash(key) 的值表示经过散列函数计算得到的散列值。 散列函数的特点： 1.确定性 如果两个散列值是不相同的（
散列、散列函数
weixin_38324954的博客
07-12 3193
1.散列表(Hash table) 散列表（又称哈希表）是一种数据集，其中数据项的存储方式尤其有利于将快速的查找定位。 散列表中的每一个存储位置，称为槽（slot）,可以用来保存数据项，每个槽有一个唯一的名称 例如：一个包含11个槽的散列表，槽的名称分别为0~10。在插入数据项之前，每个槽的值都是None，表示空槽。 散列函数 实现从数据项到存储槽名称的转换的，称为散列函数(Hash function)。 下面示例中，散列函数接受数据项作为参数，返回整数值0~10，表示数据项存储的槽号。 有一种常用的散列
哈希函数（散列函数）详解
weixin_40423737的博客
12-19 4192
哈希函数（散列函数）Hash，一般翻译做”散列”，也有直接音译为”哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 哈希函
解析散列函数：从原理到应用
博客
08-31 1412
散列函数是一种将输入数据映射到固定大小的散列值的函数。它通过对输入数据进行计算，生成一个唯一的散列值，用于快速查找或验证数据的完整性。本文从散列函数的原理、应用、常见算法比较以及设计原则等方面对散列函数进行了解析。散列函数在数据结构中的散列表和密码学中的哈希函数中有着广泛的应用。不同的散列函数算法在性能和安全性方面有所差异，评估散列函数的性能可以通过理论分析、实验测试和模拟仿真等方法。在设计散列函数时，应遵循均匀分布原则、碰撞概率最小化原则、抗碰撞性原则、易于计算原则和易于实现原则。
[数据结构] 基于交换的排序 冒泡排序&&快速排序
最新发布
水墨不写bug
07-06 659
让右下标先走，向左寻找比key小的值，找到后停下来：停下来后：左下标再向右寻找比key大的值，找到后停下来：此时，交换两个下标对应的值：接下来继续执行上述步骤（R先走），我展示关键步骤：两下标找到要求目标并交换：直到遇到特殊情况：两下标相遇这时停止停止循环，将最左侧元素与相遇处的元素交换位置：即可完成一次二分。
第五章：查找-2021-11
08-03
第五章"查找"是数据结构与算法中的重要内容之一，本章主要涵盖了查找的基本概念和各种查找算法的实现及应用。在本章中，我们首先介绍了查找的基本概念，然后详细讨论了顺序查找、分块查找、折半查找等常见的查找算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值