算法和数据结构解析-7 : 哈希表相关问题

于 2022-07-17 14:54:04 发布
阅读量299 收藏 1
点赞数
分类专栏： 设计模式与算法 文章标签： 数据结构 散列表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405670/article/details/125825830
版权

1. 哈希表数据结构概念

1.1 基本概念

哈希表（Hash Table）也叫散列表，是可以根据关键字值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键字值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数（哈希函数），存放记录的数组就叫做散列表。

哈希表里保存的数据元素是一组键-值对（key-value pair），它的特性就是可以根据给出的 key 快速访问 value。

哈希表在不考虑冲突的情况下，插入、删除和访问操作时间复杂度均为O(1)。

1.2 核心问题

设计一个哈希表，有两个核心问题需要去解决：

  1. 如何设计哈希方法（哈希函数）
  2. 如何避免哈希碰撞

哈希方法（hash method，也叫哈希函数）会将键值映射到某块存储空间。

一个好的哈希方法，应该将不同的键值，均匀地分布在存储空间中。理想情况下，每个值都应该有一个对应唯一的散列值。

哈希方法要将大量的键值，映射到一个有限的空间里。这样就有可能会将不同的键值，映射到同一个存储空间，这种情况称为 “哈希碰撞” （Hash Collision，也叫“哈希冲突”）。哈希碰撞是不可避免的，但可以用策略来解决哈希碰撞。

为了解决 哈希碰撞 ，我们利用 桶 来存储所有对应的数值。桶可以用 数组 或 链表 来实现（Java中就是用链表来实现的）。

2. 只出现一次的数字

2.1 题目说明

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]

输出: 1

示例 2:

输入: [4,1,2,1,2]

输出: 4

2.2 分析

这是基于数组的一道题目。

题目中除了一个元素之外，其它都出现两次。所以我们可以想到，只要把元素是否出现过记录下来，遍历完数组就可以判断出单独的那个数了。

2.3 方法一：暴力法

基本想法是，遍历数组，把当前所有出现的单独元素都另外保存下来。遇到重复的就删除。

    // 方法一：暴力法
    public int singleNumber1(int[] nums){
        // 定义一个列表，保存当前所有出现过一次的元素
        ArrayList<Integer> singleNumList = new ArrayList<>();

        // 遍历所有元素
        for (Integer num: nums){
            if (singleNumList.contains(num)){
                // 如果已经出现过，删除列表中的元素
                singleNumList.remove(num);
            } else {
                // 没有出现过，直接保存
                singleNumList.add(num);
            }
        }
        return singleNumList.get(0);
    }

复杂度分析

时间复杂度：O(n^2)。我们遍历nums 花费O(n) 的时间；另外我们还要在列表中遍历，判断是否存在这个数字，再花费 O(n) 的时间，所以总循环时间为 O(n^2)。

空间复杂度：O(n)。我们需要一个大小为 n 的列表保存所有的 nums 中元素。

2.4 方法二：保存到HashMap

由于在列表中查询需要耗费线性时间，所以可以想到，可以把数不保存到列表，而是保存到HashMap中，这样查询的时候不就不用再遍历一次了。

    // 方法二：保存单独的元素到HashMap
    public int singleNumber2(int[] nums){
        HashMap<Integer, Integer> singleNumMap = new HashMap<>();

        for (Integer num: nums){
            if (singleNumMap.get(num) != null)
                singleNumMap.remove(num);
            else
                singleNumMap.put(num, 1);
        }

        return singleNumMap.keySet().iterator().next();
    }

复杂度分析
时间复杂度：O(n) 。for 循环的时间复杂度是 O(n)。而HashMap的 get 操作时间复杂度为O(1) 。
空间复杂度：O(n) 。HashMap需要的空间与nums中元素个数相等。

2.5 方法三：保存到set

也可以利用set来进行去重，然后计算set中所有元素的总和。得到的总和乘以2，就是所有元素加了两遍；对比原数组，只多了一个那个落单的数。所以减去原数组的总和，就是要找的那个数。

    // 方法三：用set去重，a = 2 * (a+b+c) - (a+b+c+b+c)
    public int singleNumber3(int[] nums){
        // 定义一个HashSet进行去重
        HashSet<Integer> set = new HashSet<>();
        int arraySum = 0;
        int setSum = 0;

        // 1. 遍历数组元素，保存到set，并直接求和
        for (int num: nums){
            set.add(num);
            arraySum += num;
        }
        // 2. 集合所有元素求和
        for (int num: set)
            setSum += num;

        // 3. 计算结果
        return setSum * 2 - arraySum;
    }

时间复杂度：O(n) 。计算sum和，会将nums中的元素遍历一遍，再将set中的元素遍历一遍。我们可以认为是遍历了两遍。

空间复杂度：O(n) 。HashSet 需要的空间跟 nums 中元素个数一致。

2.6 方法四：位运算

我们回忆一下数学上异或运算的概念：

  •  如果对 0 和二进制位做 XOR 运算，得到的仍然是这个二进制位

a⊕0=a

  • 如果对相同的二进制位做 XOR 运算，返回的结果是 0

a⊕a=0

  • XOR 满足交换律和结合律

a⊕b⊕a=(a⊕a)⊕b=0⊕b=b

所以我们只需要将所有的数进行 XOR 操作，就能得到那个唯一的数字

    // 方法四：数学方法（做异或）
    public int singleNumber(int[] nums){
        int result = 0;
        // 遍历所有数据，按位做异或
        for (int num: nums)
            result ^= num;

        return result;
    }

复杂度分析

时间复杂度：O(n)，其中 n 是数组长度。只需要对数组遍历一次。

空间复杂度：O(1)。

3. 最长连续序列

3.1 题目说明

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

进阶：你可以设计并实现时间复杂度为 O(n) 的解决方案吗？

示例 1：

输入：nums = [100,4,200,1,3,2]

输出：4

解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

示例 2：

输入：nums = [0,3,7,2,5,8,4,6,0,1]

输出：9

提示：

  1. 0 <= nums.length <= 104
  2. -109 <= nums[i] <= 109

3.2 分析

要寻找连续序列，关键在于找到当前数的“下一个数”（或者叫“后继”）。

如果有后继，就在数组中继续找，每找到一个后继，当前序列长度就加1；直到找不到时，就得到了以当前数开始的、最长的连续序列长度。

3.3 方法一：暴力法

最简单的实现，就是遍历所有数据，对每一数据都找从它开始的最长连续序列。

寻找连续序列，就是要不停寻找后继。而判断后继是否存在，又要在数组中进行遍历寻找。

    // 方法一：暴力法
    public int longestConsecutiveSequence1(int[] nums){
        // 定义一个变量，保存当前最长连续序列的长度
        int maxLength = 0;

        // 遍历数组，以每个元素作为起始点，寻找连续序列
        for (int i = 0; i < nums.length; i++){
            // 保存当前元素作为起始点
            int currNum = nums[i];
            // 保存当前连续序列长度
            int currLength = 1;

            // 寻找后续数字，组成连续序列
            while ( contains(nums, currNum + 1) ){
                currLength ++;
                currNum ++;
            }

            // 判断当前连续序列长度是否为最大
            maxLength = currLength > maxLength ? currLength : maxLength;
        }

        return maxLength;
    }
    
    // 定义一个方法，用于在数组中寻找某个元素
    public boolean contains(int[] nums, int x){
        for (int num: nums){
            if (num == x)
                return true;
        }
        return false;
    }

复杂度分析

时间复杂度：O(N^3)。我们定义了外层循环遍历数组，内层循环不停寻找后继；另外，在内层循环中每次要判断后继是否存在，还需要遍历数组查找。所以总计是O(N^3)。

空间复杂度：O(1)。过程中只用到了一些辅助的临时变量。

3.4 方法二：哈希表改进

用哈希表（Hash Set）来保存数组中的元素，可以快速判断元素是否存在。这样contains可以优化为常数时间复杂度。

    // 方法二：利用哈希表改进
    public int longestConsecutiveSequence2(int[] nums){
        // 定义一个变量，保存当前最长连续序列的长度
        int maxLength = 0;

        // 定义一个HashSet，保存所有出现的数值
        HashSet<Integer> hashSet = new HashSet<>();

        // 1. 遍历所有元素，保存到HashSet
        for (int num: nums){
            hashSet.add(num);
        }

        // 2. 遍历数组，以每个元素作为起始点，寻找连续序列
        for (int i = 0; i < nums.length; i++){
            // 保存当前元素作为起始点
            int currNum = nums[i];
            // 保存当前连续序列长度
            int currLength = 1;

            // 寻找后续数字，组成连续序列
            while ( hashSet.contains(currNum + 1) ){
                currLength ++;
                currNum ++;
            }

            // 判断当前连续序列长度是否为最大
            maxLength = currLength > maxLength ? currLength : maxLength;
        }

        return maxLength;
    }

复杂度分析

时间复杂度：O(N^2)。将数组元素保存入Hash Set需要。后面由于简化了内层循环中判断后继的过程，只耗费O(1)时间，所以最终是内外两重循环，最坏情况下时间复杂度为O(N^2)。

空间复杂度：O(N)。我们用到了一个Hash Set来保存数组元素，排除部分重复数据，这仍然需要耗费O(N)的内存空间。

3.5 方法三：哈希表进一步优化

仔细分析上面的算法过程，我们会发现其中执行了很多不必要的枚举。
例如，我们已经寻找过x开始的连续序列，已知有一个 x,x+1,x+2,⋯,x+y 的连续序列。现在要继续寻找x+1开始的连续序列，算法会重新寻找它的后继x+2，而这个过程我们已经做过了。
并且，我们可以确定，这种情况得到的结果（连续序列的长度），肯定不会优于以x 为起点的答案。因此这部分处理完全没有必要，我们在外层循环的时候碰到这种情况，直接跳过即可。

    // 方法三：进一步改进
    public int longestConsecutiveSequence(int[] nums){
        // 定义一个变量，保存当前最长连续序列的长度
        int maxLength = 0;

        // 定义一个HashSet，保存所有出现的数值
        HashSet<Integer> hashSet = new HashSet<>();

        // 1. 遍历所有元素，保存到HashSet
        for (int num: nums){
            hashSet.add(num);
        }

        // 2. 遍历数组，以每个元素作为起始点，寻找连续序列
        for (int i = 0; i < nums.length; i++){
            // 保存当前元素作为起始点
            int currNum = nums[i];
            // 保存当前连续序列长度
            int currLength = 1;

            // 判断：只有当前元素的前驱不存在的情况下，才去进行寻找连续序列的操作
            if (!hashSet.contains(currNum - 1)) {
                // 寻找后续数字，组成连续序列
                while ( hashSet.contains(currNum + 1) ){
                    currLength ++;
                    currNum ++;
                }

                // 判断当前连续序列长度是否为最大
                maxLength = currLength > maxLength ? currLength : maxLength;
            }
        }

        return maxLength;
    }

复杂度分析

时间复杂度：O(N)。外层循环需要 O(n) 的时间复杂度，只有当一个数是连续序列的第一个数的情况下才会进入内层循环，然后在内层循环中匹配连续序列中的数，因此数组中的每个数只会进入内层循环一次。

空间复杂度：O(N)。哈希表保存数组中所有数据需要O(N)的内存空间。

4.LRU缓存机制

4.1 题目说明

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。

实现 LRUCache 类：

  1. LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
  2. int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
  3. void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：

输入

["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]

[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]

输出

[null, null, null, 1, null, -1, null, -1, 3, 4]

解释

LRUCache lRUCache = new LRUCache(2);

lRUCache.put(1, 1); // 缓存是 {1=1}

lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}

lRUCache.get(1);    // 返回 1

lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}

lRUCache.get(2);    // 返回 -1 (未找到)

lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}

lRUCache.get(1);    // 返回 -1 (未找到)

lRUCache.get(3);    // 返回 3

lRUCache.get(4);    // 返回 4

提示：

  1. 1 <= capacity <= 3000
  2. 0 <= key <= 3000
  3. 0 <= value <= 104
  4. 最多调用 3 * 104 次 get 和 put

4.2 分析

LRU（Least recently used，最近最少使用）是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。

所谓的“最近最久未使用”，就是根据数据的历史访问记录来判断的，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

LRU是最常见的缓存机制，在操作系统的虚拟内存管理中，有非常重要的应用，所以也是面试中的常客。

具体实现上，既然保存的是键值对，而且要根据key来判断数据是否在缓存中，那么就可以用一个HashMap来作为缓存的存储数据结构。这样，我们的访问和插入，就都可以以常数时间进行了。

需要额外考虑的是，缓存空间有限，所以这个HashMap要有一个容量限制；而且当达到容量上限时，我们会运用LRU的策略删除最近最少使用的那个数据。

这就要求我们必须把数据，按照一定的线性结构排列起来，最新访问的数据放在后面，新数据的插入可以“顶掉”最前面的不常访问的数据。这种数据结构其实可以用链表来实现。

所以，我们最终可以使用一个哈希表+双向链表的数据结构，来实现LRU缓存机制。

4.3 方法一：使用LinkedHashMap

在java语言中，其实java.util下已经给我们封装好了这样的一个数据结构，就是“链式哈希表”——LinkedHashMap。它本身继承了HashMap，而它的节点Entry除了继承自HashMap.Node，还定义了before和after两个指针，从而实现了双向链表。

package com.webcode.hashmap;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCacheWithLinkedHashMap extends LinkedHashMap<Integer,Integer> {

    // 定义缓存容量
    private int capacity;

    public LRUCacheWithLinkedHashMap(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    // 访问数据的get方法
    public int get(int key){
        if (super.get(key) == null) return -1;
        return super.get(key);
    }

    // put方法
    public void put(int key, int value){
        super.put(key, value);
    }

    // 重写是否删除元素的方法
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }

    public static void main(String[] args) {
        LRUCacheWithLinkedHashMap lRUCache = new LRUCacheWithLinkedHashMap(2);
        lRUCache.put(1, 1); // 缓存是 {1=1}
        lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
        System.out.println(lRUCache.get(1));   // 返回 1
        lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
        System.out.println(lRUCache.get(2));    // 返回 -1 (未找到)
        lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
        System.out.println(lRUCache.get(1));     // 返回 -1 (未找到)
        System.out.println(lRUCache.get(3));     // 返回 3
        System.out.println(lRUCache.get(4));     // 返回 4
    }
}

4.4 方法二：自定义哈希表+双向链表

上面的实现虽然简单，但是有取巧的嫌疑，如果在真正的面试中给出这样的代码，很可能面试官是无法满意的。我们需要做的，还是自己实现一个简单的双向链表，而不是直接套用语言自带的封装数据结构

package com.webcode.hashmap;

import java.util.HashMap;

// 自定义实现HashMap+双向链表的缓存机制
public class LRUCache {
    // 定义双向链表的节点类
    class Node {
        int key;
        int value;
        Node next;
        Node prev;   // 指向前一个节点的指针

        public Node() {
        }

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    // 定义哈希表
    private HashMap<Integer, Node> hashMap =  new HashMap<Integer, Node>();
    // 定义属性
    private int capacity;
    private int size;

    // 定义头尾指针
    private Node head, tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;

        // 用哑节点定义哨兵，方便统一处理
        head = new Node();
        tail = new Node();

        head.next = tail;
        tail.prev = head;
    }

    // get方法
    public int get(int key){
        // 从哈希表中查找key，如果不存在的话就返回-1
        Node node = hashMap.get(key);
        if (node == null) return -1;

        // 如果存在，将当前节点移到链表末尾
        moveToTail(node);

        return node.value;
    }

    // put操作
    public void put(int key, int value){
        // 同样先在哈希表中查找key
        Node node = hashMap.get(key);

        // 如果key存在，修改value，并移到末尾
        if (node != null){
            node.value = value;
            moveToTail(node);
        }
        // 如果不存在，需要创建新的节点，插入到末尾
        else {
            Node newNode = new Node(key, value);
            hashMap.put(key, newNode);    // 保存进哈希表
            addToTail(newNode);    // 添加到双向链表的末尾
            size ++;    // 当前size增大

            // 如果超出了容量限制，删除链表头节点
            if (size > capacity){
                Node head = removeHead();
                hashMap.remove(head.key);
                size --;
            }
        }
    }

    // 移动节点到链表末尾
    private void moveToTail(Node node){
        removeNode(node);
        addToTail(node);
    }

    // 通用方法，删除链表中的某一个节点
    private void removeNode(Node node){
        // 跳过当前node
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    // 在链表末尾增加一个节点
    private void addToTail(Node node){
        node.next = tail;
        node.prev = tail.prev;    // 以原先的末尾节点作为前一个节点
        tail.prev.next = node;
        tail.prev = node;
    }

    // 删除头节点
    private Node removeHead(){
        Node realHead = head.next;
        removeNode(realHead);
        return realHead;
    }
    public static void main(String[] args) {
        LRUCache lRUCache = new LRUCache(2);
        lRUCache.put(1, 1); // 缓存是 {1=1}
        lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
        System.out.println(lRUCache.get(1));   // 返回 1
        lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
        System.out.println(lRUCache.get(2));    // 返回 -1 (未找到)
        lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
        System.out.println(lRUCache.get(1));     // 返回 -1 (未找到)
        System.out.println(lRUCache.get(3));     // 返回 3
        System.out.println(lRUCache.get(4));     // 返回 4
    }
}

复杂度分析

时间复杂度：O(1)。因为使用了HashMap和双向链表，对于 put 和 get 操作都可以在 O(1)时间完成。

空间复杂度：O(capacity)，因为哈希表和双向链表最多存储capacity+1个元素（超出缓存容量时，大小为capacity+1）。

鮀城小帅
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值