散列（Hash）之习题分析

最新推荐文章于 2024-01-03 17:23:04 发布
最新推荐文章于 2024-01-03 17:23:04 发布
阅读量765 收藏 2
点赞数 1
分类专栏： 算法 文章标签： 链表 数据结构 java hash hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyyyya/article/details/112293210
版权

散列（Hash）之习题分析

一、什么是散列（Hash）

（一）、Hash的概念

​ 若结构中存在和关键字K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数（Hash function），按这个事先建立的表为散列表。

​ 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2)，这种现象称碰撞。具有相同函数值的关键字对该散列函数来说称做**同义词。综上所述，根据散列函数H(key)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象” 作为记录在表中的存储位置，这种表便称为散列表，这一映象过程称为散列造表或散列，所得的存储位置称散列地址**。

​ 若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数（Uniform Hash function），这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。

（二）、处理冲突的方法

  • 开放寻址法；Hi=(H(key) + di) MOD m,i=1,2,…，k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法：

    • di=1,2,3,…，m-1，称线性探测再散列；
    • di=12,-12,22,-22,32,…，±k2,(k<=m/2)称二次探测再散列；
    • di=伪随机数序列，称伪随机探测再散列。

  • 再散列法：Hi=RHi(key),i=1,2,…，k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。

  • 链地址法(拉链法)

  • 建立一个公共溢出区

二、HashMap解析

（一）、HashMap的概念

​ HashMap 主要用来存放键值对，它基于哈希表的Map接口实现，是常用的Java集合之一。

​ JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间，具体可以参考 treeifyBin方法。

（二）、HashMap的属性

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列号
    private static final long serialVersionUID = 362498820763181265L;    
    // 默认的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30; 
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8; 
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组，总是2的幂次倍
    transient Node<k,v>[] table; 
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数，注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;   
    // 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
    int threshold;
    // 加载因子
    final float loadFactor;
}

  • loadFactor加载因子

    loadFactor加载因子是控制数组存放数据的疏密程度，loadFactor越趋近于1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor越小，也就是趋近于0，数组中存放的数据(entry)也就越少，也就越稀疏。

    loadFactor太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor的默认值为0.75f是官方给出的一个比较好的临界值。

    给定的默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。

  • threshold

    threshold = capacity * loadFactor，当Size>=threshold的时候，那么就要考虑对数组的扩增了，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。

（三）、构造方法

    // 默认构造函数。
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all   other fields defaulted
     }
     
     // 包含另一个“Map”的构造函数
     public HashMap(Map<? extends K, ? extends V> m) {
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);//下面会分析到这个方法
     }
     
     // 指定“容量大小”的构造函数
     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
     }
     
     // 指定“容量大小”和“加载因子”的构造函数
     public HashMap(int initialCapacity, float loadFactor) {
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
         if (initialCapacity > MAXIMUM_CAPACITY)
             initialCapacity = MAXIMUM_CAPACITY;
         if (loadFactor <= 0 || Float.isNaN(loadFactor))
             throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
         this.loadFactor = loadFactor;
         this.threshold = tableSizeFor(initialCapacity);
     }

（四）、HashMap的常用方法

1、put方法
（1）、1.7以前
  • ①如果定位到的数组位置没有元素 就直接插入。
  • ②如果定位到的数组位置有元素，遍历以这个元素为头结点的链表，依次和插入的key比较，如果key相同就直接覆盖，不同就采用头插法插入元素。
public V put(K key, V value)
    if (table == EMPTY_TABLE) { 
    inflateTable(threshold); 
}  
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 先遍历
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue; 
        }
    }

    modCount++;
    addEntry(hash, key, value, i);  // 再插入
    return null;
}
（2）、1.7以后

HashMap只提供了put用于添加元素，putVal方法只是给put方法调用的一个方法，并没有提供给用户使用。

对putVal方法添加元素的分析如下：

  • ①如果定位到的数组位置没有元素 就直接插入。
  • ②如果定位到的数组位置有元素就和要插入的key比较，如果key相同就直接覆盖，如果key不相同，就判断p是否是一个树节点，如果是就调用e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)将元素添加进入。如果不是就遍历链表插入(插入的是链表尾部)。
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table未初始化或者长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;
        // hash值不相等，即key不相等；为红黑树结点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 为链表结点
        else {
            // 在链表最末插入结点
            for (int binCount = 0; ; ++binCount) {
                // 到达链表的尾部
                if ((e = p.next) == null) {
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    // 结点数量达到阈值，转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}
2、get方法
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 数组元素相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个节点
        if ((e = first.next) != null) {
            // 在树中get
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 在链表中get
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}
3、resize方法

进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是非常耗时的。在编写程序中，要尽量避免resize。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        // 超过最大值就不再扩充了，就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 没超过最大值，就扩充为原来的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else { 
        // signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { 
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

（五）、底层数据分析

1、1.7以前
static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).

    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

在这里插入图片描述

2、1.7以后
static final int hash(Object key) {
      int h;
      // key.hashCode()：返回散列值也就是hashcode
      // ^ ：按位异或
      // >>>:无符号右移，忽略符号位，空位都以0补齐
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

在这里插入图片描述

以上关于HashMap解析内容参考JavaGuide的文章HashMap(JDK1.8)源码+底层数据结构分析（https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/HashMap(JDK1.8)源码+底层数据结构分析.md）

三、子数组和等于K

（一）、题目需求

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

说明 :

数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

（二）、解法

public int subarraySum(int[] nums, int k) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    for (int i = 1; i < nums.length; i++) {
        nums[i] += nums[i - 1];
    }

    int ans = 0;
    int temp = 0;
    Map<Integer, Integer> map = new HashMap<>();
    // 对于下标为 0 的元素，前缀和为 0，个数为 1
    map.put(0, 1);
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(nums[i] - k)) {
            ans += map.get(nums[i] - k);
        }
        temp = map.containsKey(nums[i]) ? map.get(nums[i]) + 1 : 1;
        map.put(nums[i], temp);
    }
    return ans;
}

（三）、习题分析

1、计算每个位置元素以及前面元素的和

for (int i = 1; i < nums.length; i++) {
    nums[i] += nums[i - 1];
}

2、定义并初始化相关变量，第一个元素的前缀和为0。而前缀和为0的元素个数为1。

int ans = 0;
int temp = 0;
Map<Integer, Integer> map = new HashMap<>();
// 对于下标为 0 的元素，前缀和为 0，个数为 1
map.put(0, 1);

3、循环判断每个位置元素是否满足要求

（1）、判断当前位置的值与K的差值，判断该值是否存在于map中，若存在则说明存在前缀和为该值的元素，则数量+1.

（2）、判断当前位置的值是否存在于map中，当前位置的值即为后一位置元素的前缀和，若遍历至最后一位元素，则为所有元素的和。当当前位置的值存在于map中时，则以该值作为前缀和的数量+1。否则则赋值为1.

for (int i = 0; i < nums.length; i++) {
    if (map.containsKey(nums[i] - k)) {
        ans += map.get(nums[i] - k);
    }
    temp = map.containsKey(nums[i]) ? map.get(nums[i]) + 1 : 1;
    map.put(nums[i], temp);
}

四、图的克隆

（一）、题目需求

给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。

图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
    public int val;
    public List<Node> neighbors;
}

测试用例格式：

简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

示例 1：

img

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

示例 2：

img

输入：adjList = [[]]
输出：[[]]
解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。

示例 3：

输入：adjList = []
输出：[]
解释：这个图是空的，它不含任何节点。

示例 4：

img

输入：adjList = [[2],[1]]
输出：[[2],[1]]

提示：

  1. 节点数不超过 100 。
  2. 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
  3. 无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
  4. 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
  5. 图是连通图，你可以从给定节点访问到所有节点。

（二）、解法

1、Node类
public class Node {

    public int val;
    public List<Node> neighbors;

    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }

    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }

    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}
2、解法
public Node cloneGraph(Node node) {
    if (node == null) {
        return null;
    }
    ArrayList<Node> list = getNodeList(node);
    Map<Node, Node> mapping = new HashMap<>();
    // 克隆node
    for (Node n : list) {
        mapping.put(n, new Node(n.val));
    }
    // 克隆neighbors
    for (Node n : list) {
        Node newNode = mapping.get(n);
        for (Node neighbor : n.neighbors) {
            Node newNeighbor = mapping.get(neighbor);
            newNode.neighbors.add(newNeighbor);
        }
    }
    return mapping.get(node);
}

private ArrayList<Node> getNodeList(Node node) {
    Queue<Node> queue = new LinkedList<>();
    Set<Node> set = new HashSet<>();
    queue.add(node);
    set.add(node);
    while (!queue.isEmpty()) {
        Node head = queue.poll();
        for (Node neighbor : head.neighbors) {
            if (!set.contains(neighbor)) {
                set.add(neighbor);
                queue.add(neighbor);
            }
        }
    }
    return new ArrayList<>(set);
}

（三）、习题分析

1、定义并初始化queue与set

（1）、queue：用于辅助遍历图

（2）、set：存储图中每个节点

Queue<Node> queue = new LinkedList<>();
Set<Node> set = new HashSet<>();
queue.add(node);
set.add(node);

2、通过queue进行遍历图，并将图中元素加入set中

while (!queue.isEmpty()) {
    Node head = queue.poll();
    for (Node neighbor : head.neighbors) {
        if (!set.contains(neighbor)) {
            set.add(neighbor);
            queue.add(neighbor);
        }
    }
}

3、利用上文得出的set链表，进行结点的复制

// 克隆node
for (Node n : list) {
    mapping.put(n, new Node(n.val));
}

4、遍历链表，并逐个结点的复制其连接节点

// 克隆neighbors
for (Node n : list) {
    Node newNode = mapping.get(n);
    for (Node neighbor : n.neighbors) {
        Node newNeighbor = mapping.get(neighbor);
        newNode.neighbors.add(newNeighbor);
    }
}

五、最长无重复的字符串

（一）、题目需求

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

（二）、解法

public int lengthOfLongestSubstring(String s) {
    Set<Character> set = new HashSet<Character>();
    int right = 0;
    int max = 0;
    for (int i = 0; i < s.length(); i++) {
        while (right < s.length() && !set.contains(s.charAt(right))) {
            set.add(s.charAt(right++));
            max = Math.max(max, right - i);
        }
        set.remove(s.charAt(i));
    }
    return max;
}

（三）、习题分析

1、利用set集合存储不重复元素的特点，以及right指针进行遍历判断。定义并初始化set与right指针

Set<Character> set = new HashSet<Character>();
int right = 0;
int max = 0;

2、for循环逐个元素进行判断，每个元素皆判断当前right指针是否存在set集合中，若不存在则right指针右移一位，意味着以当前元素为首字符的字符串的长度+1，赋予max值。

直到right指针所指元素已存在于set集合中，则以当前元素为首字符的字符串长度判断完毕，移除set集合中当前位置的元素。继续判断下一位置元素为首字符的情况

for (int i = 0; i < s.length(); i++) {
    while (right < s.length() && !set.contains(s.charAt(right))) {
        set.add(s.charAt(right++));
        max = Math.max(max, right - i);
    }
    set.remove(s.charAt(i));
}
hyyyya
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法练习题Exercise6.doc
05-30
本练习题主要涉及查找算法，特别是关于排序、哈希表、二叉树等概念。 1. 折半查找（Binary Search）是一种在有序数组中查找特定元素的搜索算法。在已知有序表（11，22，33，44，55，66，77，88，99）中查找55，折半...
哈希表冲突及处理冲突的方法（含例子）
Super_King_的博客
10-20 2769
哈希法又称散列法、杂凑法以及关键字地址计算法等，相应的表成为哈希表。基本思想：首先在元素的关键字K和元素的位置P之间建立一个对应关系f，使得P=f(K),其中f成为哈希函数。创建哈希表时，把关键字K的元素直接存入地址为f(K)的单元；查找关键字K的元素时利用哈希函数计算出该元素的存储位置P=f(K).
散列的一些算法题
kevin的博客
08-19 364
散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。 关于散列表更加详细可以看这里散列及散列函数 下面我们通过几个leetcode上的题目加深对散列的理解和使用 两数之和 给定一个整数数组 nums...
谁是你的潜在朋友
小一的专栏
02-07 2167
前言 闲来无事，又ac了一道水题 题目 题目描述： “臭味相投”——这是我们描述朋友时喜欢用的词汇。两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份北大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。 首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N
PAT---散列题总结
chstor's blog
05-13 216
散列： 将元素通过一个函数转换为整数，使得该整数可以尽量唯一地代表这个元素。 散列函数： 一般直接用STL中的map或unordered_map，除非必须模拟这些方法或者对算法效率要求较高，否则不需要自己实现解决冲突的方法 ①直接定址法 恒等变换：将 key(输入的数) 作为数组下标 ⭐——最常见最实用 线性变换：H(key) = a * key + b ②平方取中法 取 key 平方的中间若干位作为 hash 值（很少用） ③除留取余法 H(key) = key % mod (表长Tsize &
散列 --- 解题必备良品
qq_19018277的博客
01-04 170
一定要学会散列！
第9章(查找)-练习题.doc
最新发布
01-10
查找算法、数据结构和散列技术 本文总结了查找算法、数据结构和散列技术相关的知识点，涵盖了二分查找、折半查找、平衡二叉树、B树和B+树、散列技术等方面。 1. 用二分（对半）查找表的元素的速度比用顺序法：二分...
c代码-散列表练习题：电话狂人
07-14
"电话狂人"这个练习题很可能是设计一个C语言程序，用散列表来解决与电话号码相关的问题，比如存储和查找联系人。 散列表的核心是散列函数，它将键转化为数组的索引。一个好的散列函数应该使得不同键尽可能地分散在...
清华大学-数据结构习题和答案
01-25
8. **散列表（Hash Table）**：散列表通过散列函数将键映射到数组索引，提供快速的查找、插入和删除操作。解决冲突的方法有开放寻址法和链地址法。 9. **字符串（String）**：字符串是字符序列，处理字符串的问题...
hash冲突及解决方法（平均查找长度）
qq_41475583的博客
07-09 1万+
一、什么是hash冲突？ 假设hash表的大小为9（即有9个槽），现在要把一串数据存到表里：5,28,19,15,20,33,12,17,10 简单计算一下：hash(5)=5, 所以数据5应该放在hash表的第5个槽里；hash(28)=1，所以数据28应该放在hash表的第1个槽里；hash(19)=1，也就是说，数据19也应该放在hash表的第1个槽里——于是就造成了碰撞（也称为冲突，collision）。 二、Hash冲突解决方法： 1.开放定址法(再散列法)： 基本思想：当关键字key的哈希地址p
散列表相关题目（线性探测再散列法）
weixin_43697439的博客
12-02 1万+
散列表相关题目（线性探测再散列法） 一、题目 将关键字序列（7、8、30、11、18、9、14）散列存储到散列表中。散列表的存储空间是一个下标从0开始的一维数组，散列函数为H(key)=(key×3) mod 7，处理冲突采用线性探测再散列法，要求装填（载）因子为0.7。 1）请画出所构造的散列表。 2）分别计算等概率情况下查找成功和查找不成功的平均查找长度。 二、解题思路及步骤 下面是详细的解题过程及方法思路 ①第（1）问 ②第（2）问 总结 （1）注意红字部分的内容！！！ （2）注意在使用线
Hash表（哈希表、散列表）
SUMUP
10-06 572
一、基本概念 散列函数：一个把查找表中的关键字映射成该关键字对应的地址的函数，记为Hash(key)=Addr。（地址可以是数组下标，索引，或内存地址等） 冲突：散列函数可能会把两个和两个以上的不同关键字映射到同一地址。（冲突不可避免，所以要设计好的处理冲突的方法。） 同义词：发生碰撞的不同关键字为同义词。 散列表：根据关键字直接进行访问的数据结构。散列表是建立在关键字和存储地址之间的一种
两道散列算法题
大佛拈花的博客
04-03 3537
一 不同散列的计算 给定数据{4371,1323,6173,4199,4344,9679,1989}和散列函数h,给出下列结果 分离链接散列表 使用线性探测散列表 使用平方探测散列表 将上述中的散列表再散列 解答： 使用链接散列表。这个是使用链表解决冲突。表的长度为10. 可以看出链表法总共有三次冲突。 线性探测：4371%10=1，没有冲突；1323%10=3，没有冲突；617...
关于双重散列（double hashing）和Brent 改进算法(Brent’s improvement)的一道例题
weixin_46638851的博客
01-14 754
关于双重散列（double hashing）和Brent 改进算法(Brent’s improvement)的一道例题
散列表相关知识及编程练习总结
热门推荐
张彦峰的博客
10-27 1万+
哈希表相关知识及编程练习总结：背景知识+应用举例（Spring框架或其他框架中的应用举例+实际开发中的应用举例）+相关编程练习（无重复字符的最长子串+有效的数独+最小覆盖子串+字母异位词分组+有效的字母异位词+找到字符串中所有字母异位词+LRU缓存机制+多数元素+重复的DNA序列+快乐数+存在重复元素+存在重复元素+单词规律+前K个高频元素+字符串中的第一个唯一字符+四数相加 II+和为K的子数组+最常见的单词+同构字符串+两个数组的交集+两个数组的交集 II+分糖果+宝石与石头）
散列表（三）：冲突处理的方法之开地址法（线性探测再散列的实现）
winform采集
07-31 2566
二、开地址法 基本思想：当关键码key的哈希地址H0 = hash(key)出现冲突时，以H0为基础，产生另一个哈希地址H1 ，如果H1仍然冲突，再以H0 为基础，产生另一个哈希地址H2 ，…，直到找出一个不冲突的哈希地址Hi ，将相应元素存入其中。这种方法有一个通用的再散列函 数形式： 其中H0 为hash(key) ，m为表长，di称为增量序列。增量序列的取值方式不同，相应的再散列...
java 哈希冲突
qq_51194826的博客
11-09 634
问题一 ： 什么是哈希冲突 通过哈希函数产生的哈希值是有限的，而数据可能比较多，导致经过哈希函数处理后仍然有不同的数据对应相同的哈希值。这时候就产生了哈希冲突。 问题二：怎么解决哈希冲突 开放地址法；再哈希法；链地址法（拉链法）；公共溢出区法。 开放地址法：开放地址法处理冲突的基本原则就是出现冲突后按照一定算法查找一个空位置存放 ...
二次探测再散列法解决哈希冲突
2301_76885122的博客
01-03 1111
二次探测再散列法解决哈希冲突
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值