【码无巨细】实现一个HashMap

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量711 收藏 1
点赞数
分类专栏： java面试 文章标签： java hashmap 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41662115/article/details/121430252
版权

力扣题

这道题在力扣上有设计哈希映射。想过的话，很简单，按照哈希表的设计原理，设计一个简易的HashMap类就好。

一个简易的HashMap需要支持三个方法：

  • void put(K key, V value)
  • V get(K key)
  • void remove(K key)

为了实现哈希节点链表数组，还需要指定数组的容量capacity和设计节点类HashNode。下面是我这道题的答案【很简陋】：

class MyHashMap {

    int capacity;
    HashNode[] hashList;
    public MyHashMap() {
        this.capacity = 1000;
        this.hashList = new HashNode[this.capacity];
    }
    
    public void put(int key, int value) {
        int i = key % this.capacity;
        HashNode node = this.hashList[i];
        HashNode pre = null;
        while (node != null && node.key != key) {
            pre = node;
            node = node.next;
        }
        if (node == null) {
            if (pre == null) {
                this.hashList[i] = new HashNode(key, value);
            } else {
                pre.next = new HashNode(key, value);
            }
        } else {
            node.value = value;
        }
    }
    
    public int get(int key) {
        int i = key % this.capacity;
        HashNode node = this.hashList[i];
        while (node != null && node.key != key) {
            node = node.next;
        }
        if (node == null) {
            return -1;
        } else {
            return node.value;
        }
    }
    
    public void remove(int key) {
        int i = key % this.capacity;
        HashNode node = this.hashList[i];
        HashNode pre = null;
        while (node != null && node.key != key) {
            pre = node;
            node = node.next;
        }
        if (node != null && pre != null) {
            pre.next = node.next;
        } else if (node != null) {
            this.hashList[i] = node.next;
        }
    }
}

class HashNode {
    int key;
    int value;
    HashNode next;
    public HashNode(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

/**
 * Your MyHashMap object will be instantiated and called as such:
 * MyHashMap obj = new MyHashMap();
 * obj.put(key,value);
 * int param_2 = obj.get(key);
 * obj.remove(key);
 */

Java源码（JDK14）

实现一个简易哈希表就这么简单，但是Java源码是如何实现它的值得我们深究，下面解析一下官方代码【完整源码见官方文档，这里只挑重要的说明】：

HashMap类注释

  1. 哈希表基于Map接口实现，提供了所有可选的map操作，允许null值和null键。
  2. HashMap和Hashtable大致等同，唯一区别是前者线程不同步，且允许空值空键。
  3. HashMap是无序的，内部顺序可能随着时间变化。
  4. get和put的时间复杂度是常数时间的。
  5. 如果在乎迭代性能，切记不要把初始容量设置太大，也不要把装载因子设置太小。
  6. 哈希表会在条目数超过装载因子*当前容量时发生重哈希（rehash）和扩容（至原来的2倍）。
  7. 装载因子的默认值是0.75，是时间性能和空间代价的折中。更高的值会降低空间代价，但会带来更高的查询代价。
  8. 谨记：HashMap是线程不同步的。如果多线程同时操作一个hashmap，并且至少有一个线程结构化地修改了hashmap，那么它必须被显式同步synchronize。结构化地修改具体是指插入或删除一个映射，仅仅是该表一个已有键的值并不算结构化修改。实际中最好将HashMap·封装到线程安全类中，比如Collections.synchronizedMap`是一个很好的工具。
  9. 不要在遍历HashMap的时候结构化的修改它（增加或删除）。

类声明

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

具体实现的注释前言

  1. HashMap通常是一个桶哈希，但是当桶太大时，太大的桶会转化成树，每个桶就类似于TreeMap的实现。当树变小的时候，又会退化成桶。
  2. 理想状态下，桶中节点的频率服从泊松分布（参数平均为0.5，在默认装载因子为0.75的情况下）。忽略方差的影响，每个位置发生碰撞时，那么这个位置的链表数大于等于8的概率小于1/1000000，因此，将装载因子设置为0.7~0.75（默认值）之间。

重要的成员变量

  1. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 默认初始容量，必须是2的幂次。
  2. static final int MAXIMUM_CAPACITY = 1 << 30; 最大容量，2的幂次。
  3. static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认装载因子
  4. static final int TREEIFY_THRESHOLD = 8; 树化的桶大小阈值
  5. static final int UNTREEIFY_THRESHOLD = 6; 桶化的树大小阈值，仅用于resize发生时，重哈希导致某些位置的树节点变少，低于此阈值时退化成桶
  6. static final int MIN_TREEIFY_CAPACITY = 64; 最小的树化的容量阈值，。应该至少为TREEIFY_THRESHOLD的4倍。否则会引发resize和树化的冲突。

桶节点类

非常简单，都是一些Object的方法。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

hash函数

HashMap中在计算键的哈希值时，使用了这个函数：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

可以看到，他并没有直接使用key.hashCode()作为键的哈希值，而是将其hashCode()的高16位和低16位做了异或，再作为键的哈希值，这种操作叫做扰动函数。

之所以在哈希时需要扰动，是因为Object.hashCode()会得到一个32位的int值，这个值在int空间中是松散的，但不见得在HashMap中是松散的（因为容量是有限的，如默认16）。在HashMap的键空键中，假设容量为16，则会只取hashCode()的低4位，这有可能会发生很严重的碰撞。但是，如果把hashCode()的高16位，拉下来和低16位做一个异或，那么就扰动了32位的信息，从而能够降低碰撞的风险。

成员变量

  1. transient Node<K,V>[] table;
  2. transient Set<Map.Entry<K,V>> entrySet;
  3. transient int size;
  4. transient int modCount; （结构化）修改计数器
  5. int threshold; 扩容阈值（容量*装载因子）
  6. final float loadFactor; 装载因子

构造器

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);
}

其中，阈值threshold的获取是用这个函数，这个函数利用了位运算，非常高效，给定一个数cap，输出不小于cap的最小2的幂次数。

static final int tableSizeFor(int cap) {
    int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

Size()和isEmpty()

返回哈希表的大小，没什么好说的

public int size() {
    return size;
}

判断是否为空

public boolean isEmpty() {
    return size == 0;
}

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) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

get方法首先要调用hash()计算key的哈希值，再通过getNode方法获取key对应的节点，如果节点不为空，则返回value值。其中hash()函数做了扰动处理，对key.hashcode()的高16位和低16位做异或（不同jdk版本的实现方案不同）。

仔细看getNode的实现细节，有几点：

  1. 判定首要条件：哈希表不为空 && 哈希表的长度不为0 && 哈希表中hash对应桶的第一个元素不为空。
  2. 计算hash % (n-1)时，用位运算加速hash & (n-1)
  3. hash % (n-1)用来定位桶，hash用来比较key是否相同。
  4. 总是先检查每个桶的第一个节点first，如果是要获取的键，则返回first。
  5. 节点e是目标节点的判断条件是e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))。注意，需要同时满足hash相同和key相等。hash值是调用Object.hashcode()方法获取的，而key相等包括内存相等或equals()方法相等，因此，如果要实现自定义类的HashMap功能，需要设计好自定义类的hashcode()和equals()，缺一不可。
  6. 如果first节点是树状节点，则执行树状搜索方法getTreeNode()。

put方法

put方法调用了putVal方法来实现插入更新。需要注意的有：

  1. **put方法是有返回值的。**如果put是插入，则返回null，如果是更新，则返回旧值。
  2. resize()方法用来初始化table或扩张原table，详见下文。
  3. 如果哈希表为空，或长度为0，则调用resize()初始化。
  4. 如果hash%(n-1)对应的桶的第一个元素为空，则在这个位置上新建一个节点。
  5. 3和4均不满足，则进入到桶链表中搜索。搜索条件仍是hash值相同且key相等。如果第一个节点为目标节点，则记录之；否则如果第一个节点是树状节点，则转到树状节点插入putTreeVal；否则，对桶链表遍历，如果有满足条件的节点，则记录之，否则，插入新节点，且判断此时位置是否超过树化阈值，如果超过，则执行树化逻辑treeifyBin()。
  6. 如果找到了目标节点，则执行更新逻辑。
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;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        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;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

至于resize()方法，无非就是新建一个更大的（2倍于原来的）哈希表，并把原来的桶链表用新的哈希函数（原来是hash%(oldCap-1)，现在是hash%(newCap-1)）打散到新的哈希表中。如果原来是树状的，则需要调用节点的split方法对树分割。代码稍长，不做具体分析了。

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;
        }
        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 {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    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) {
        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 { // preserve order
                    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;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

remove方法

remove方法和put方法就大同小异了，一个是定位节点修改（或插入），一个是定位节点并删除。

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

clear()

clear()非常简单粗暴，对每一个桶，直接做null赋值。

publicvoid clear() {
    Node<K,V>[] tab;
    modCount++;
    if ((tab = table) != null && size > 0) {
        size = 0;
        for (int i = 0; i < tab.length; ++i)
            tab[i] = null;
    }
}

containsKey方法

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

调用getNode找到和key对应的节点，不为空则存在。

containsValue()

如果你把哈希表比作一个二维节点矩阵的话，哈希表存储每一个桶链表的指针，那么判断值是否存在其实是一个双层遍历，没有加速操作，复杂度是O(n^2)

public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (Node<K,V> e : tab) {
            for (; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

HashSet

至于HashSet的源码实现，则是完全用HashMap来代替的，插入元素时，哈希表的值设置为一个哑对象：
在这里插入图片描述
在这里插入图片描述

shenziming_hitcs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud集成Seata saga模式案例
健身变秃，coding变强
04-04 4337
SpringCloud集成Seata saga模式案例
java无锁hashmap原理与实现详解
09-04
无锁HashMap的设计和实现是并发编程中的一个重要话题，它通过避免互斥锁的使用，提升了多线程环境下的性能。通过CAS操作和无锁链表，可以在并发环境下保证数据的正确性和一致性。在Java中，`ConcurrentHashMap`是...
mfc连接mysql增删改查_java实现mysql数据库增删改查
weixin_39761195的博客
02-17 106
1.连接数据库:import java.sql.Connection;import java.sql.DriverManager;public class DBConnection {static String driver = "com.mysql.jdbc.Driver";static String url= "jdbc:mysql://localhost:3306/mydatabase01?...
服务器接口Android学习笔记47：使用HttpClient接口实现网络通信
love android
05-27 1148
在本篇文章中,我们重要介绍服务器接口的内容,自我感觉有个不错的建议和大家分享下      在Android中，我们可以通过使用标准的Java接口来完成Android应用程序的联网操纵。但是在现实开辟中，可能会需要用到更复杂的联网操纵，为此，Android平台供给了Apache HttpClient接口，为客户端的HTTP编程供给了高效、便捷、功能丰富的工具包支持。      Android平台
java util包中map应用
wokeke的专栏
07-25 159
自：http://linux.net527.cn/Linuxwendang/kaifahuanjing/java/30691.html [table] |开拓职员：J2EE JavaMap聚拢类简介 作者：JackShirazi 了解最常用的聚拢范例之一Map的根本知识以及怎样针对您操纵措施特有的数据优化Map。 java.util中的聚拢类包孕Java中某些最常用的类。最常用的聚拢类是Lis...
2018Java面试题及答案【面试必看】
会飞的鱼
11-08 4810
4、&amp;和&amp;&amp;的差别   答：?&amp;是位运算符，表示按位与运算，&amp;&amp;是逻辑运算符，表示逻辑与（and）   5、Collection 和 Collections的差别   答：?Collection是聚集类的下级接口，承继与他的接口重要有Set 和List.Collections是针对聚集类的一个赞助类，他供给一系列静态办法实现对各类聚集的搜...
优秀的C++库
个人进步之路
03-07 1277
优秀的C++库
新手编程导论
农发行小伟
10-11 6534
第一部分 前 言 By Chenyi 眼前这本书充分体现了作者的所思、所想、所感，他用自己独特的眼光审视着计算机技术的世界，也用自己独特的思维逻辑对技术进行解读，并用自己特有的，呵呵，偶尔带有“四个逗号=一个逗号”这样的语言风格，进行着自己的诠释。创新是一种美，独立思考也是：） 学习是一件因人而异的事情，因为每个人的生活经历、教育背景、年龄、认知模型等等，都是不尽相同的，也
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
Java HashMap实现原理分析（一）
09-07
HashMap的实现原理基于哈希表，它的核心是通过哈希函数将键（key）映射到一个数组的特定位置，从而实现快速访问。本文将深入解析HashMap的put和get操作的内部机制。 首先，HashMap的底层数据结构是一个动态扩容的...
Java8 HashMap的实现原理分析
09-02
Java8之后新增挺多新东西，接下来通过本文给大家介绍Java8 HashMap的实现原理分析，对java8 hashmap实现原理相关知识感兴趣的朋友一起学习吧
Jdk1.8 HashMap实现原理详细介绍
08-31
首先，HashMap是一个基于哈希表的数据结构，它实现了Map接口。它不保证映射的顺序，并且是非同步的。这意味着在多线程环境中，如果不进行同步控制，可能会出现并发问题。HashMap的核心数据结构是一个Node数组，每个...
golang 接口
m0_70982551的博客
07-24 950
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 513
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 638
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 593
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 361
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 423
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
手写一个hashmap
04-01
抱歉，我是一名语言模型AI，没有具体的编程能力，无法手写一个hashmap，但我可以给你提供一个hashmap的基本实现思路： 1.定义一个数组，数组的长度为2的整数次幂，这样可以使得数组下标的计算更加高效。 2.定义一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值