Hash(哈希/散列)表中冲突处理及命中计算

最新推荐文章于 2023-06-30 07:43:49 发布
最新推荐文章于 2023-06-30 07:43:49 发布
阅读量1.5k 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 哈希算法 散列表 算法
原文链接：https://blog.csdn.net/Game_jqd
版权

/

hash：音译哈希，意译散列，用于在规定大小的表中，快速插入和查找数据。

　　构造哈希表的几种方法：

　　　　1.直接定址法（取关键字的某个线性函数为哈希地址）

　　　　2.除留余数法（取关键值被某个不大于散列表长m的数p除后的所得的余数为散列地址）

　　　　3.平方取中法（关键字平方后，取中间一段数字）

　　　　4.折叠法

　　　　5.随机数法

　　　　6.数学分析法

　　常用方法是直接定址法和除留余数法

　　一般做的题目都是喜欢自己写哈希的，简单而且好控制因为题目要求。直接定址题目一般会给你方法的，在此讲余数法。

冲突处理

　　冲突处理分成大类和小类，大类为开散列方法( open hashing，也称为拉链法，separate chaining ) 和 闭散列方法( closed hashing，也称为开地址方法，open addressing )。

　　开散列我没写过，不提了，以后被坑可能会补。

　　闭散列最常用的两个：线性探测(Linear probing) 和 二次探测(Quadratic probing)。（英文苦逼注意下，沙雕博主看不懂二次和探测的英文，结果卡题卡半天啊。看下混个眼熟）

　　一、线性探测

　　　　key = Hash(key) + 1

　　　　key = Hash(key) + 2    以此类推。说明：hash（key）就是构造哈希的方法。

　　　如果是余数法，而且是来回探测的话：

　　　　key =（Hash(key) + 1） % size

　　　　key =（Hash(key) - 2 + size） % size     以此类推

　　　探测系数一直到size为止，那么也就是直到表满都放得下

　　二、二次探测

　　　　key = Hash(key) + 1*1

　　　　key = Hash(key) + 2*2    以此类推

　　　如果是余数法，而且是来回探测的话：

　　　　key =（Hash(key) + 1*1） % size

　　　　key =（Hash(key) - 2*2 + size） % size     以此类推

　　　探测系数一直到size为止，如果路上查到的key都有数据的话，那么这个数据无法放入（题目特殊要求按题目定）

命中计算

　　其实没什么难度，主要是被坑了不爽无能狂怒rua

　　按构表法和冲突处理法进行查找，没进行一次查找，查找次数+1，如果当前的查找那个位置是空的话，代表找不到，那么结束

　　如果冲突系数一直到size还没找到，那么超过size的那次判断也算作一次查找　　

//msize是表的容量
for(j=0;j<msize;j++) {
    cnt++;
        //没有找到或者找到了都算结束了
    if(a[(x%msize + j*j) % msize] == 0) break;
    if(a[(x%msize + j*j) % msize] == x) break;
}
//冲突处理完的这个判断，也算一次查找
if(j == msize) cnt++;
//除以总数，算平均值
printf("%.1lf\n",cnt*1.0/m);

　　其实这个命中率并没有什么明确的规定，在此提出只是表示 “啊，这么狗的命中率也有啊” 的感想。刷题时（不管是比赛还是测试），都要随机应变，依靠样例去猜出题人的想法，今天可能出界+1，明天就可能没查到不算一次查询。

//

构造哈希表之二次探测法

HashTable-散列表/哈希表

是根据关键字（key）而直接访问在内存存储位置的数据结构。

它通过一个关键值的函数将所需的数据映射到表中的位置来访问数据，这个映射函数叫做散列（哈希）函数，存放记录的数组叫做散列表。

构造哈希表的几种方法
1.直接定址法（取关键字的某个线性函数为哈希地址）
2.除留余数法（取关键值被某个不大于散列表长m的数p除后的所得的余数为散列地址）
3.平方取中法
4.折叠法
5.随机数法
6.数学分析法
常用方法是 直接定址法和 除留余数法

哈希冲突/哈希碰撞
不同的Key值经过哈希函数Hash(Key)处理以后可能产生相同的值哈希地址，我们称这种情况为哈希冲突。任意的散列函数都不能避免产生冲突。

处理哈希碰撞的方法
若key1,key2,key3产生哈希冲突(key1,key2,key3值不相同，映射的哈希地址同为key)，用以下方法确定它们的地址

1.闭散列法
1）线性探测
若当前key与原来key产生相同的哈希地址，则当前key存在该地址之后没有存任何元素的地址中
key1：hash(key)+0
key2：hash(key)+1
key3：hash(key)+2
例如：

2）二次探测
若当前key与原来key产生相同的哈希地址，则当前key存在该地址后偏移量为（1,2,3...）的二次方地址处
key1：hash(key)+0
key2：hash(key)+1^2
key3：hash(key)+2^2
例如：


2.开链法（哈希桶）
哈希表中保存包含每个key值的节点，每个节点有一个_next的指针，指向产生哈希冲突的key的节点
例如：

 

 

构建哈希表（二次探测法）

支持key值为字符串

<pre name="code" class="cpp">//HashTable.h
#pragma once
#include<iostream>
#include <string>
using namespace std;
enum State
{
    EMPTY,//空
    EXITS,//存在
    DELETE//已删除
};
 
template<class K, class V>
struct HashTableNode
{
    K _key;
    V _value;
};
 
 
 
 
template<class K>
struct _HashFunc
{
    size_t operator()(const K& key,const size_t& capacity)//哈希函数，仿函数
    {
        return key / capacity;
    }
 
};
template<>
struct _HashFunc<string>//模板特化
{
private:
    unsigned int _BKDRHash(const char *str)//key为字符串时哈希函数
    {
        unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
        unsigned int hash = 0;
 
        while (*str)
        {
            hash = hash * seed + (*str++);
        }
        return (hash & 0x7FFFFFFF);
    }
public:
    size_t operator()(const string& key,const size_t& capacity)//仿函数
    {
 
        return _BKDRHash(key.c_str()) % capacity;
    }
 
};
template<class K, class V,class HashFunc=_HashFunc<K>>
class HashTable
{
 
    typedef HashTableNode<K, V> Node;
public:
    HashTable(size_t capacity = 10)
        :_tables(new Node[capacity])
        , _states(new State[capacity])
        , _size(0)
        , _capacity(capacity)
    {}
    ~HashTable()
    {
        if (_tables != NULL)
        {
            delete[] _tables;
            delete[] _states;
        }
    
    }
    HashTable(const HashTable<K, V>& ht)
    {
        HashTable<K, V> tmp(ht._capacity);
        for (size_t i = 0; i < ht._capacity; i++)
        {
            tmp.Insert(ht._tables[i]._key, ht._tables[i]._value);
        }
        this->Swap(tmp);
    }
    HashTable& operator=(HashTable<K, V> ht)
    {
        this->Swap();
        return *this;
    }
    bool Insert(const K& key, const V& value)
    {
        _CheckCapacity();
        size_t index = HashFunc()(key, _capacity);
        size_t i = 1;
        while (_states[index] == EXITS)//二次探测
        {
            if (_tables[index]._key == key)
            {
                return false;
            }
            index = index + 2 * i - 1;
            index %= _capacity;
            ++i;
        }
        _tables[index]._key = key;
        _tables[index]._value = value;
        _states[index] = EXITS;
        ++_size;
        return true;
    }
 
    bool Find(const K& key)
    {
        size_t index = HashFunc()(key, _capacity);
        size_t start = index;
        size_t i = 1;
        while (_states[index] != EMPTY)//根据二次探测法查找
        {
            if (_tables[index]._key == key)
            {
                if (_states[index] != DELETE)
                    return true;
                else
                    return false;
            }
            index = index + 2 * i - 1;
            index %= _capacity;
            if (start == index)
                return false;
        }
        return false;
    }
    bool Remove(const K& key)
    {
        size_t index = HashFunc()(key, _capacity);
        size_t start = index;
        size_t i = 1;
        while (_states[index] != EMPTY)//根据二次探测法删除
        {
            if (_tables[index]._key == key)
            {
                if (_states[index] != DELETE)
                {
                    _states[index] = DELETE;
                    _size--;
                    return true;
                }
                else
                    return false;
            }
            index = index + 2 * i - 1;
            index %= _capacity;
            if (start == index)
                return false;
        }
        return false;
 
 
    }
    void Print()
    {
        for (size_t i = 0; i < _capacity; i++)
        {
            //printf("%d-[%s:%s] \n", _states[i], _tables[i]._key, _tables[i]._value);
            cout << _states[i] << " " << _tables[i]._key << " " << _tables[i]._value<<endl;
        }
    }
private:
    void Swap(HashTable<K, V>& tmp)
    {
        swap(_tables, tmp._tables);
        swap(_states, tmp._states);
        swap(_size, tmp._size);
        swap(_capacity, tmp._capacity);
    }
    void _CheckCapacity()//增容
    {
        if (_size * 10 / _capacity == 6)
        {
            HashTable<K, V> tmp(_capacity * 2);
            for (size_t i = 0; i < _capacity; i++)
            {
                if (_states[i] == EXITS)
                    tmp.Insert(_tables[i]._key, _tables[i]._value);
            }
            this->Swap(tmp);
        }
    }
 
private:
    Node* _tables;//哈希表
    State* _states;//状态表
    size_t _size;
    size_t _capacity;
};
 


</pre><pre code_snippet_id="1711228" snippet_file_name="blog_20160608_3_3809584" name="code" class="cpp">//test.cpp
#include<iostream>
#include "HashTable.h"
void testInt()
{
    HashTable<int, int> table(10);
    table.Insert(89, 89);
    table.Insert(18, 18);
    table.Insert(49, 49);
    table.Insert(58, 58);
    table.Insert(9, 9);
    //table.Insert(45, 45);
    //table.Insert(2, 2);
    table.Print();
    HashTable<int, int> table1(table);
    table1.Print();
    bool ret = table.Find(9);
    cout << endl << ret << endl;
    table.Remove(9);
    table.Print();
 
}
void TestString()
{
    HashTable<string, string> table(10);
    table.Insert("dict", "字典");
    table.Insert("hash", "哈希");
    table.Insert("function", "函数");
    table.Insert("abcd", "函数");
    table.Insert("dcba", "函数");
 
    table.Print();
    bool ret = table.Find("function");
    cout << endl << ret << endl;
    table.Remove("hash");
    table.Print();
}
int main()
{
    //testInt();
    TestString();
    getchar();
    return 0;
}

测试结果：

/

构造哈希表之开链法（哈希桶）

描述一下哈希桶的基本原理：

哈希表中保存包含每个key值的节点，每个节点有一个_next的指针，指向产生哈希冲突的key的节点

#pragma once
#include<iostream>
#include<vector>
#include<string>
using namespace std;
 
template<class K>
struct _HashFunc
{
    size_t operator()(const K& key,size_t capacity)
    {
        return key%capacity;
    }
};
template<>
struct _HashFunc<string>//string类特化
{
 
    static size_t _BKDRHash(const char * str)
    {
        unsigned int seed = 131; // 31 131 1313 13131 131313
        unsigned int hash = 0;
        while (*str)
        {
            hash = hash * seed + (*str++);
        }
        return (hash & 0x7FFFFFFF);
    }
    size_t operator()(const string& key, size_t capacity)
    {
        return _BKDRHash(key.c_str()) % capacity;
    }
};
 
template<class K,class V>
struct HashTableNode
{
    HashTableNode(const K& key, const V& value)
    :_key(key)
    , _value(value)
    ,_next(NULL)
    {}
    K _key;
    V _value;
    HashTableNode<K,V>* _next;
};
 
const int _PrimeSize = 28;
const unsigned long _PrimeList[_PrimeSize] =
{
    53ul, 97ul, 193ul, 389ul, 769ul,
    1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
    1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    1610612741ul, 3221225473ul, 4294967291ul
};//素数表，将哈希表容量控制为素数，使用素数做除数可以减少哈希冲突
template<class K, class V, class HashFunc = _HashFunc<K> >
class HashTable
{
public:
 
    typedef HashTableNode<K, V> Node;
 
    HashTable(const HashTable<K,V>& ht)
        :_size(0)
    {
        _tables.resize(ht._tables.size());
        for (size_t i = 0; i < ht._tables.size(); i++)
        {
            Node* cur = ht._tables[i];
            while (cur)
            {
                Insert(cur->_key, cur->_value);
                cur = cur->_next;
                _size++;
            }
        }
 
    }
    HashTable& operator=(HashTable<K, V> ht)
    {
        swap(_tables, ht._tables);
        return *this;
    }
    ~HashTable()
    {
        for (size_t i = 0; i < _tables.size(); i++)
        {
            Node* cur = _tables[i];
            while (cur)
            {
                Node* del = cur;
                cur = cur->_next;
                delete del;
            }
        }
 
    }
    HashTable(const size_t& capacity)
        :_size(0)
    {
        _tables.resize(_GetCapacity(0));
    }
    bool Insert(const K& key,const V& value)
    {
        _CheckCapacity();
        size_t index = HashFunc()(key,_tables.size());
        Node* cur = _tables[index];
        while (cur)
        {
            if (cur->_key == key)
                return false;
            cur = cur->_next;
        }
        Node* NewNode = new Node(key, value);
        NewNode->_next = _tables[index];
        _tables[index] = NewNode;
        _size++;
    }
    Node* Find(const K& key)
    {
        size_t index = HashFunc()(key, _tables.size());
        Node* cur = _tables[index];
        while (cur)
        {
            if (cur->_key == key)
                return cur;
            cur = cur->_next;
        }
        return NULL;
    }
    bool Remove(const K& key)
    {
        size_t index = HashFunc()(key, _tables.size());
        Node* cur = _tables[index];
        if (cur == NULL)
            return false;
        if (cur->_key == key && cur)
        {
            _tables[index] = cur->_next;
            delete cur;
            cur = NULL;
            return true;
        }
        Node* prev = NULL;
        while (cur)
        {
            prev = cur;
            cur = cur->_next;
            if (cur->_key == key)
            {
                prev->_next = cur->_next;
                delete cur;
                return true;
            }
        
        }
        return false;
    }
 
    void Print()
    {
        for (size_t i = 0; i < _tables.size(); i++)
        {
            Node* cur = _tables[i];
            while (cur)
            {
                cout << cur->_key << ":" << cur->_value << "->";
                cur = cur->_next;
            }
            cout << "NULL" << endl;
        }
    }
private:
    void _CheckCapacity()
    {
        if (_size == _tables.size())
        {
            size_t capacity = _GetCapacity(_size);
            vector<Node*> tab;
            tab.resize(capacity);
            for (size_t i = 0; i < _tables.size(); i++)
            {
                Node* cur = _tables[i];
                while (cur)
                {
                    Node* tmp = cur;
                    cur = cur->_next;
                    size_t index = HashFunc()(tmp->_key, tab.size());
                    tmp->_next = tab[index];
                    tab[index] = tmp;
                }
                _tables[i] = NULL;
            }
            _tables.swap(tab);
        }
        
    }
 
    size_t _GetCapacity(const size_t& capacity)
    {
        for (size_t i = 0; i<_PrimeSize; i++)
        {
            if (capacity < _PrimeList[i])
                return _PrimeList[i];
        }
    }
 
private:
    vector<Node*> _tables;
    size_t _size;
};
 

#include"HashTableBucket.h"
void TestInt()
{
    HashTable<int, int> tab(10);
    tab.Insert(51,51);
    tab.Insert(105,105);
    tab.Insert(52,52);
    tab.Insert(3,3);
    tab.Insert(55,55);
    tab.Insert(2,2);
    tab.Insert(106,106);
    tab.Insert(53,53);
    tab.Insert(0,0);
    /*for (int i = 0; i < 53; i++)
    {
        tab.Insert(i,i);
    }
    tab.Insert(54,54);*/
    tab.Print();
    //HashTable<int, int> ht(tab);
    HashTable<int, int> ht(tab);
    ht = tab;
    /*HashTableNode<int,int>* node=tab.Find(54);
    cout << node->_key << " " << node->_value << endl;*/
    cout << ":------------" << endl;
    /*tab.Remove(0);
    tab.Print();*/
    ht.Print();
    
}
void TestString()
{
    HashTable<string, string> ht(0);
    ht.Insert("hhh","jjjj");
    ht.Insert("het", "haxi");
    ht.Insert("kk", "kkkk");
    HashTableNode<string, string>* node=ht.Find("het");
    ht.Print();
    cout << node->_key<< node->_value << endl;
}
int main()
{
    //TestInt();
    TestString();
    getchar();
    return 0;
}
 

/

警醒与鞭策
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构笔记40】哈希表冲突处理方法：开放地址法（线性探测、平方探测、双散列、再散列），分离链接法
记录学习痕迹的公众号：Piper蛋窝
10-22 4448
两种解决哈希表冲突的思想。
计算链地址法存储的哈希表中的冲突次数
m0_74050308的博客
10-09 487
【代码】计算链地址法存储的哈希表中的冲突次数。
哈希冲突概率计算及python仿真
chenxy_bwave的专栏
12-21 1412
Hash函数不是计算理论的中基本概念，计算理论中只有单向函数的说法。所谓的单向函数，是一个复杂的定义，严格的定义要参考理论或者密码学方面的书籍。用“人类”的语言描述单向函数就是：如果某个函数在给定输入的时候，很容易计算出其结果来；而当给定结果的时候，很难计算出输入来，这就是单向函数。各种加密函数都可以被认为是单向函数的逼近。Hash函数（或者成为散列函数）也可以看成是单向函数的一个逼近。即它接近于满足单向函数的定义。Hash函数还有更通俗的理解方式，即它代表的是一种关于数据的压缩映射。
散列表（二）：冲突处理的方法之链地址法的实现
winform采集
07-31 762
首先需要澄清的一点是，这里讲的是hash table ，即数据项所存储的表要用数组来实现。 一、链地址法 这种基本思想：将所有哈希地址为i 的元素构成一个称为同义词链的链表，并将链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在 同义词链中进行。 该散列方法首先对关键码集合用某一个散列函数计算它们的存放位置。 若设散列表地址空间的所有位置是从0到m-1，则关键码集合...
浅谈哈希表及哈希冲突.ppt
09-20
哈希表是一种数据结构，它通过使用哈希函数将键（Key）映射到一个固定大小的数组（也称为哈希表或散列表）中的特定位置，以此实现快速的查找、插入和删除操作。哈希表的核心在于哈希函数，它能将任意大小的键转化...
哈希表相关概念、hash函数、hash冲突解决方案、代码示例
01-15
2. **再散列函数法**：使用第二个或更多的哈希函数来重新计算哈希值，减少冲突的可能性。这种方法增加了计算复杂性，但能有效地分散数据。 3. **链地址法**：在每个哈希表的槽位上附加一个链表，所有映射到同一位置...
关于哈希（散列）算法的8个问题
01-07
按这个思路，采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或者哈希表。那么关键字对应的记录存储位置我们称为散列地址。 散列技术最适合的求解问题是查找与给定值相等的记录。对于...
哈希表（链地址法处理冲突）swust oj#1012
01-03
当两个数的余数相同时仅仅凭借余数作为下标来查找就会发生错误即hash冲突，那么链地址法其实就是将余数相同的数用链表储存起来，那么查找时就遍历余数对应的链表即可（类似邻接表） 题目出处 #include #include ...
哈希表Hash table 用于哈希表等的 C 宏
最新发布
01-15
// uthash 的哈希处理字段 } my_data_t; ``` 2. **初始化哈希表**：不需要显式地初始化整个哈希表，只需要确保你的结构体实例化后，`hh`字段为NULL即可。 3. **插入元素**：使用`HH_ADD`宏将新元素添加到哈希表...
java 哈希冲突
qq_51194826的博客
11-09 626
问题一 ： 什么是哈希冲突 通过哈希函数产生的哈希值是有限的，而数据可能比较多，导致经过哈希函数处理后仍然有不同的数据对应相同的哈希值。这时候就产生了哈希冲突。 问题二：怎么解决哈希冲突 开放地址法；再哈希法；链地址法（拉链法）；公共溢出区法。 开放地址法：开放地址法处理冲突的基本原则就是出现冲突后按照一定算法查找一个空位置存放 ...
冲突计数
weixin_30251587的博客
11-20 113
indexAttr.CM.getTakeupList(data, function (res) { if (res && res.S) { if (res.D) { /** * dataObj是所有人的冲突数据 * eg： * { * '647123': [{},{}]...
hash冲突是什么？
闲来垂钓碧溪上的博客
06-30 150
当我们在一堆数据中查找一个元素时，使用普通方法得到的时间复杂度是O(N)，使用搜索树的时间复杂度为O(logn)，而现在告诉你有一种数据结构可以只使用O(1)的时间复杂度就可以查找，对程序的效率提升是一种质的飞跃。而这就是哈希（散列）。；capacity为存储元素底层空间总的大小。
散列冲突次数测试C语言
让阳光照进心里
10-23 1354
  用来模拟使用线性探测法散列,平方探测法散列,双散列发生冲突的次数.  可指定随机序列大小,可反复生成随机序列.可指定表的大小,并可更改表的大小.方便对各种长度随机数序列,各种大小的表进行模拟测试.实现思想就是用表的指定大小创建一个数组,并将所有元素初始化为0.进行模拟时,根据随机序列中的所有数值依次计算出在表中的索引,如果表中该索引的元素为0,将该元素置为OCCUPANCY,否则冲突计数器++,并尝试下一次模拟插入.重复此过程,之后返回冲突计数器的值,释放表的空间.  代码写的比较臃肿,模块性较好.有优
哈希表（散列表）详解（包含哈希表处理冲突的方法）
天涯路的专栏
05-16 812
哈希表（散列表）详解（包含哈希表处理冲突的方法） 前面介绍了静态查找表以及动态查找表中的一些查找方法，其查找的过程都无法避免同查找表中的数据进行比较，查找算法的效率很大程度取决于同表中数据的查找次数。 而本节所介绍的哈希表可以通过关键字直接找到数据的存储位置，不需要进行任何的比较，其查找的效率相较于前面所介绍的查找算法是更高的。 哈希表的构建 在初中的数学课本中学习过函数的相关知识，给定一个 x，通过一个数学公式，只需要将 x 的值带入公式就可以求出一个新的值 y。 哈希表的建立同函数类似，把函数中的
Hash表和Hash冲突
qq906237201的博客
06-24 603
Hash表和Hash冲突Hash表中的元素存储地址是通过Hash函数计算出来的，当要取出指定元素的时候，直接通过Hash函数计算出元素的存储地址。有时候会出现KEY不同，但是通过Hash函数计算出来的值相同，这个值相同意味着这两个KEY要存在同一位置，这显然不对，这就是Hash冲突。 Hash函数有多种构造方法，常见的有直接定址法、数字分析法、平方取中法、折叠法、除留余数法、随机数法等，这里选择除
计算使用线性探测、平方探测以及双散列插入的长随机序列所需要的冲突次数
wwj_bupt
05-13 2530
数据结构与算法分析——c语言描述 练习5.3  答案 三个都是一个冲突都是一个数量级，差不了太多。但每次都是双散列的最少。 hashQuad.h typedef int ElementType; #ifndef _HashQuad_H #define _HashQuad_H typedef unsigned int Index; typedef Index Posit
链式哈希命中查找运行时间数学证明
weixin_34381666的博客
06-11 149
《算法导论》中关于链式哈希命中查找运行时间数学证明，一上来就给出公式没看明白，在网上搜了一圈没找到解答心中疑问的文字，于是写下这篇。题目是计算在链式哈希表中，在均匀散列的情况下，命中查找的运行时间。分析：命中查找的运行时间，就是一个键数目n的函数，按照成本模型便是求命中查找的比较次数随n增长的增长率，即比较次数为n的函数T(n)。 设要查找键a，...
【PTA】【数据结构与算法】散列冲突
热门推荐
葑鈊丶
05-17 3万+
这里是从PTA平台整理的【散列冲突】题目集
"哈希表与冲突解决：桶排序优化与实践分析
通过对哈希表及哈希冲突的深入讨论，我们对哈希表这一数据结构的设计原理和应用场景有了更深入的理解，也为我们在实际应用中更好地选择合适的哈希函数和冲突处理方法提供了参考。同时，我们也需要不断地探索和优化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值