哈希表（一）

最新推荐文章于 2024-10-01 05:07:35 发布
最新推荐文章于 2024-10-01 05:07:35 发布
阅读量409 收藏 2
点赞数 1
分类专栏： LeetCode 文章标签： leetcode 算法 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Al_tair/article/details/126629544
版权
本文介绍了两种编程问题的解决方案：一是将整数转换为罗马数字，分别展示了暴力解法和优化后的代码；二是给定数字字符串生成所有可能的字母组合，通过递归优化减少了代码冗余并提高了运行效率。文章讨论了如何通过键值对、循环和递归等技术提高算法性能。
摘要由CSDN通过智能技术生成

哈希表

大家好呀，我是小笙！

1.整数转罗马数字

整数转换成罗马数字之间存在键值对的关系

罗马数字整数
I1
IV4
V5
IX9
X10
XL40
L50
XC90
C100
CD400
D500
CM900
M100

例子：27 写做 XXVII, 即为 XX + V + II

我的暴力解法

思路：

  • 先用键值对保存整数和罗马数字之间的关系
  • 通过每次循环找到可以相减的最大数，这样子就可以获取到最终的值
class Solution {
    public String intToRoman(int num) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"I");
        map.put(4,"IV");
        map.put(5,"V");
        map.put(9,"IX");
        map.put(10,"X");
        map.put(40,"XL");
        map.put(50,"L");
        map.put(90,"XC");
        map.put(100,"C");
        map.put(400,"CD");
        map.put(500,"D");
        map.put(900,"CM");
        map.put(1000,"M");
        // 使用 StringBuilder 是因为在单线程中 StringBuilder 对增加字符串性能是最好的效率最高
        StringBuilder sb = new StringBuilder();
        while(num != 0){
            if(num >= 1000){
                sb.append(map.get(1000)); 
                num -= 1000;
            }else if(num >= 900){
                sb.append(map.get(900)); 
                num -= 900;
            }else if(num >= 500){
                sb.append(map.get(500)); 
                num -= 500;
            }else if(num >= 400){
                sb.append(map.get(400)); 
                num -= 400;
            }else if(num >= 100){
                sb.append(map.get(100)); 
                num -= 100;
            }else if(num >= 90){
                sb.append(map.get(90)); 
                num -= 90;
            }else if(num >= 50){
                sb.append(map.get(50)); 
                num -= 50;
            }else if(num >= 40){
                sb.append(map.get(40)); 
                num -= 40;
            }else if(num >= 10){
                sb.append(map.get(10)); 
                num -= 10;
            }else if(num >= 9){
                sb.append(map.get(9)); 
                num -= 9;
            }else if(num >= 5){
                sb.append(map.get(5)); 
                num -= 5;
            }else if(num >= 4){
                sb.append(map.get(4)); 
                num -= 4;
            }else if(num >= 3){
                sb.append("III"); 
                num -= 3;
            }else if(num >= 2){
                sb.append("II"); 
                num -= 2;
            }else if(num >= 1){
                sb.append("I"); 
                num -= 1;
            }
        }
        return new String(sb);
    }
}

优化思路

由于重复代码太多（代码繁琐），我改用循环遍历解决

核心思想就是这么多个值我改用数组代替，但是效率甚至不如之前

class Solution {
    public String intToRoman(int num) {
        int[] nums = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"I");
        map.put(4,"IV");
        map.put(5,"V");
        map.put(9,"IX");
        map.put(10,"X");
        map.put(40,"XL");
        map.put(50,"L");
        map.put(90,"XC");
        map.put(100,"C");
        map.put(400,"CD");
        map.put(500,"D");
        map.put(900,"CM");
        map.put(1000,"M");
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<nums.length;i++){
            String key = map.get(nums[i]);
            while(num >= nums[i]){
                sb.append(key);
                num -= nums[i];
            }
            if(num == 0){
                break;
            }
        }
        return new String(sb);
    }
}

终极代码（模仿官方）暴力解码

核心理念：就是列出 千位 百位 十位 各位 所有可能，只需要进行一次匹配进行，效率极高

class Solution {
    String[] thousands = {"", "M", "MM", "MMM"};
    String[] hundreds  = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
    String[] tens      = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
    String[] ones      = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};

    public String intToRoman(int num) {
        StringBuffer roman = new StringBuffer();
        roman.append(thousands[num / 1000]);
        roman.append(hundreds[num % 1000 / 100]);
        roman.append(tens[num % 100 / 10]);
        roman.append(ones[num % 10]);
        return roman.toString();
    }
}
2.电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合，就是老式电话上数字对应字母，用字母拼凑出所有字母的情况（长度就是数字的数量），但是是有顺序的，第一个数字出现的字母位置必须在第一个以此类推，长度最长为4

image-20220829215639515

上来我就是一顿暴力解法,一开始我考虑多半会运行超时，但是没有，所以我就“搬出来”给大家看一下

class Solution {
    public List<String> letterCombinations(String digits) {
        int len = digits.length();
        List<String> res = new ArrayList<>();
        if(len == 0){
            return res;
        }else{
            Map<Character,String> map = new HashMap<>();
            map.put('2',"abc");
            map.put('3',"def");
            map.put('4',"ghi");
            map.put('5',"jkl");
            map.put('6',"mno");
            map.put('7',"pqrs");
            map.put('8',"tuv");
            map.put('9',"wxyz");
            char[] chs = new char[len];
            for(int i=0;i<len;i++){
                chs[i] = digits.charAt(i);
            }
            if(len == 1){
                String str = map.get(chs[0]);
                for(int i=0;i<str.length();i++){
                    res.add("" + str.charAt(i));
                }
                return res;
            }else if(len == 2){
                String str = map.get(chs[0]);
                String str1 = map.get(chs[1]);
                for(int i=0;i<str.length();i++){
                    for(int j=0;j<str1.length();j++){
                        res.add("" + str.charAt(i) + str1.charAt(j));
                    }
                }
                return res;
            }else if(len == 3){
                String str = map.get(chs[0]);
                String str1 = map.get(chs[1]);
                String str2 = map.get(chs[2]);
                for(int i=0;i<str.length();i++){
                    for(int j=0;j<str1.length();j++){
                        for(int k=0;k<str2.length();k++){
                            res.add("" + str.charAt(i) + str1.charAt(j) + str2.charAt(k));
                        }
                    }
                }
                return res;
            }else if(len == 4){
                String str = map.get(chs[0]);
                String str1 = map.get(chs[1]);
                String str2 = map.get(chs[2]);
                String str3 = map.get(chs[3]);
                for(int i=0;i<str.length();i++){
                    for(int j=0;j<str1.length();j++){
                        for(int k=0;k<str2.length();k++){
                            for(int m=0;m<str3.length();m++){
                                res.add("" + str.charAt(i) + str1.charAt(j) + str2.charAt(k) + str3.charAt(m) );
                            }
                        }
                    }
                }
                return res;
            }
            return res;
        }
    }
}

优化，从代码整洁上考虑，太多的冗余代码,使用递归来解决代码复用，同时运行速度从 13ms 到 1ms，效率提升还是很明显的

class Solution {
    public List<String> letterCombinations(String digits) {
        int len = digits.length();
        List<String> res = new ArrayList<>();
        if(len == 0){
            return res;
        }else{
            Map<Character,String> map = new HashMap<>();
            map.put('2',"abc");
            map.put('3',"def");
            map.put('4',"ghi");
            map.put('5',"jkl");
            map.put('6',"mno");
            map.put('7',"pqrs");
            map.put('8',"tuv");
            map.put('9',"wxyz");
            char[] chs = new char[len];
            String[] n = new String[len];
            for(int i=len-1;i>=0;i--){
                n[i] = map.get(digits.charAt(len-i-1));
            }
            cicle(res,len,n,new StringBuilder());
            return res;
        }
    }

    // String[] n 指的是倒叙对应数字对应的字母 比如 24 对应 ["ghi","abc"]
    public void cicle(List<String> list,int len,String[] n,StringBuilder str){
        if(len == 1){
            for(int i=0;i<=n[len-1].length()-1;i++){
                str.append("" + n[len-1].charAt(i));
                list.add(new String(str));  
                str.delete(str.length()-1,str.length());
            }
            return;
        }else{
            for(int i=0;i<=n[len-1].length()-1;i++){
                str.append("" + n[len-1].charAt(i)); 
                cicle(list,len-1,n,str);
                str.delete(str.length()-1,str.length());
            }
        }
        return;
    }
}

这个时候停止优化吗？不，我们还需要提升在算法性能，内存上达到超过90%，这是我现在所能做到最好的

class Solution {
    List<String> res = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        int len = digits.length();
        // 简化 map 添加值
        Map<Character, String> map = new HashMap<Character, String>() {{
            put('2', "abc");
            put('3', "def");
            put('4', "ghi");
            put('5', "jkl");
            put('6', "mno");
            put('7', "pqrs");
            put('8', "tuv");
            put('9', "wxyz");
        }};
        String[] n = new String[len];
        for(int i=len-1;i>=0;i--){
            n[i] = map.get(digits.charAt(len-i-1));
        }
        cicle(len,n,new StringBuilder());
        return res;
    }

    // 简化递归算法的重复代码，极简化，而且不影响效率
    public void cicle(int len,String[] n,StringBuilder str){
        if(len > 0){
            for(int i=0;i<=n[len-1].length()-1;i++){
                str.append("" + n[len-1].charAt(i)); 
                if(len > 1){
                    cicle(len-1,n,str);
                }else{
                    res.add(new String(str));  
                }
                str.delete(str.length()-1,str.length());
            }
        }
    }
}
罗念笙
关注
专栏目录
哈希表哈希表哈希表.zip
05-29
在实际应用中，为了提高性能，哈希表通常会预先设定一个较大的容量，并在负载因子（已存储元素数量/总容量）达到一定程度时进行动态扩容。 总的来说，哈希表是一种高效的数据结构，通过哈希函数和冲突解决策略实现...
哈希及常用哈希算法
qq_51106567的博客
07-04 2466
哈希介绍，哈希算法介绍。
java 中的哈希码
hi_bigguy的博客
04-02 7381
源博客地址 对哈希码和默认的toString()不了解，百度后总结如下: 一 哈希码 在Java中，哈希码代表了对象的一种特征，例如我们判断某两个字符串是否==，如果其哈希码相等，则这两个字符串是相等的。其次，哈希码是一种数据结构的算法。常见的哈希码的算法有： 1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。 ...
哈希码 总结
热门推荐
SunnyAndroider专栏
11-29 1万+
哈希码 哈希码是一种数据结构的算法。 哈希码具体是什么？ 答：hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值   常见的哈希码的算法有：   1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。   2：String类的hashCode.
什么是哈希码值
qq_41282282的博客
07-12 6081
散列函数 （或散列算法，又称哈希函数，英语：Hash Function）是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做散列值（hash values，hash codes，hash sums，或hashes）的指纹。散列值通常...
哈希表实验C语言版实现
09-05
哈希表是一种高效的数据结构，它通过特定的哈希函数将键（Key）映射到一个固定大小的数组中，从而实现快速的插入、查找和删除操作。在本实验中，哈希表的C语言实现主要涉及以下几个核心知识点： 1. **哈希表的基本...
哈希表课程设计数据结构实验报告——哈希表设计
07-05
针对某个集体中的人名设计一个哈希表，使得平均查找长度不超过R，完成相应的建立和查表程序. 1.2 人名为汉语拼音形式，最长不超过18个字符(如：庄双双 zhuangshuangshuang). 1.3 假设待填入哈希表的人名有30个，...
C语言基于哈希表实现通讯录
08-27
C语言基于哈希表实现通讯录 本文主要为大家详细介绍了C语言基于哈希表实现通讯录，具有一定的参考价值，感兴趣的小伙伴们...感兴趣的小伙伴们可以根据本文的代码和设计思路，自己尝试实现一个基于哈希表的通讯录系统。
手动构造一个哈希表
02-27
哈希表是一种高效的数据结构，它通过将键（Key）映射到数组的索引来实现快速查找、插入和删除操作。在本主题中，我们将深入探讨哈希表的原理、构造方法以及它与二叉排序树的关系。 哈希表的核心是哈希函数，它将...
LeetCode[中等] 739. 每日温度
Theolulu的博客
09-30 387
给定一个整数数组，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。
LeetCode 面试经典150题 66.加一
qq_57349657的博客
09-27 297
加一
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 250
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Java - LeetCode面试经典150题(二)
心如冰清，天塌不惊
09-28 837
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
LeetCode 69. x 的平方根
野草说技术
09-27 368
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
Golang | Leetcode Golang题解之第448题找到所有数组中消失的数字
weixin_66442839的博客
10-01 300
Golang | Leetcode Golang题解之第448题找到所有数组中消失的数字
Killing LeetCode [416] 分割等和子集
m0_37292477的博客
09-27 355
给你一个 只包含正整数 的 非空 数组 nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。解释：数组可以分割成 [1, 5, 5] 和 [11]。解释：数组不能分割成两个元素和相等的子集。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]Tag：动态规划，0-1背包问题。
LeetCode 53. 最大子数组和
fujiang_xiao的博客
09-29 303
一是 nums[ i ] 作为前面的子数组的一部分，此时 dp [ i ] = dp[ i-1] + nums[ i ]；二是 nums[ i ] 作为一个新的子数组，此时 dp[ i ] = nums[ i ]。故递推公式为 dp[ i ] = Math.max(dp[ i-1] + nums[ i ], nums[ i ] )。贪心思路，取一个变量 cnt 记录当前子数组的和，如果 cnt < 0，这时就应该舍弃原来的子数组，将 cnt 置为0，重新记录新的子数组的和。是数组中的一个连续部分。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 307
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
最新发布
Ddddddd_158的博客
10-01 263
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
哈希表实现与查找操作
在本实例中，哈希表被定义为一个结构体`HashTable`，包含了元素存储的数组`elem`、当前元素数量`count`以及哈希表的大小指数`sizeindex`。哈希表的大小是通过预定义的数组`hashsize`来动态调整的，初始大小为11。 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

罗念笙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值