Java哈希表常用操作及相关leetcode算法题

哈希表

以键值对的形式存储
存储：将key通过哈希函数映射到一个内存地址，然后将value存入该内存地址
获取：通过key传入哈希函数得到内存地址，将value取出来
哈希冲突：不同的key传入哈希函数得到的内存地址一样
解决：以链表的形式存储统一内存地址的value，要获取值时先定位到内存地址，再遍历链表
判断数据结构的好坏要对比四个操作

1、访问Access

哈希表没有索引的概念，不存在访问的操作。

2、搜索Search

时间复杂度是O(1)。将key传入哈希函数得到内存地址，取出value。
如果有哈希冲突，时间复杂度是O(k)，k是冲突个数，因为要遍历链表。

3、插入Insert

时间复杂度是O(1)。将key传入哈希函数得到内存地址，存入value。
如果有哈希冲突，时间复杂度是O(k)，k是冲突个数，因为要遍历链表。

4、删除Delete

时间复杂度是O(1)。将key传入哈希函数得到内存地址，删除value。
如果有哈希冲突，时间复杂度是O(k)，k是冲突个数，因为要遍历链表。

Java哈希表常用操作

1、创建哈希表

通过数组创建哈希表

String[] hashTable = new String[4];

HashMap

HashMap<Integer, String> map = new HashMap<>();

2、添加元素

数组

hashTable[1] = “zhangsan”;
hashTable[2]=“lisi”;
hashTable[3]=“wangwu”;

HashMap

map.put(1, “zhangsan”);
map.put(2, “lisi”);
map.put(3, “wangwu”);

3、更新元素

数组

hashTable[1] = “zhaoliu”;

HashMap

map.put(1, “zhaoliu”);
在同一个key添加元素，会覆盖前面的value

4、删除元素

数组

hashTable[1] = “”;
将value改为不会用到的值，如空字符串，如果value为空字符串，视为key不存在

HashMap

map.remove(1);

5、获取元素

HashMap

map.containsKey(1);
时间复杂度为O(1)。

6、获取元素

HashMap

int length = map.size();
时间复杂度为O(1)。

7、是否为空

HashMap

map.isEmpty();
时间复杂度为O(1)。

8、哈希表相关leetcode

No.217

思路：遍历数组，如果哈希表中的key中不包含当前元素，将当前元素作为key加入哈希表；否则表示哈希表的key中已经包含当前元素，返回true。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        if(nums == null || nums.length == 0 || nums.length == 1)
            return false;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            if(map.containsKey(nums[i]))
                return true;
            else
                map.put(nums[i], 1);
        }
        return false;
    }
}

No.389 找不同

思路：遍历字符串s，将字符串s中的字符按字符为key，个数为value存入map，然后遍历字符串t，如果当前字符不在map中，直接返回当前字符；否则，将当前字符对应的次数-1，如果-1后次数为0，就移除当前字符。

class Solution {
    public char findTheDifference(String s, String t) {
        HashMap<Character, Integer> map = new HashMap<>();
        for(char c : s.toCharArray()) {
            if(map.containsKey(c)) {
                map.put(c, map.get(c) + 1);
            } else {
                map.put(c, 1);
            }
        }
        for(char c : t.toCharArray()) {
            if(!map.containsKey(c)) {
                return c;
            } else {
                map.put(c, map.get(c) - 1);
                if(map.get(c) == 0)
                    map.remove(c);
            }
        }
        return 'a';
    }
}

推荐使用ASCII码累加的方式

class Solution {
    public char findTheDifference(String s, String t) {
        int sum1 = 0;
        int sum2 = 0;
        for(char c : s.toCharArray()) {
            sum1 += c;
        }
        for(char c : t.toCharArray()) {
            sum2 += c;
        }
        return (char)(sum2 - sum1);
    }
}

No.496 下一个更大元素

nums1[8,1,2]
nums2[2,1,0,8,7,6,5]
思路：遍历数组2，将2放进栈，然后比较1和2，1小于2，将1入栈；比较0和1，0小于1，0入栈；比较8和0，8大于0，将0，8加入map，表示0的下一个更大元素是8；比较1和8，将1，8加入map；比较2和8，将2，8加入map；栈空了，将8入栈，比较7和8，7入栈；比较6和7，6入栈；比较5和6，5入栈。也就是将当前遍历到的元素和栈顶元素相比，小于就入栈，大于就取出栈顶元素，将栈顶元素和当前元素作为键值对存入map。如果遍历完之后，栈内还有元素，说明栈内的元素都不存在下一个更大的元素，直接将它们的value设为-1存入map。最后遍历数组1，获取数组1元素在map中对应的value，赋值给result，返回。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] result = new int[nums1.length];
        Stack<Integer> stack = new Stack<>();
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums2.length; i++) {
            while(!stack.isEmpty() && nums2[i] > stack.peek()) {
                map.put(stack.pop(), nums2[i]);
            }
            stack.push(nums2[i]);
        }
        while(!stack.isEmpty()) {
            int top = stack.pop();
            map.put(top, -1);
        }
        for(int i = 0; i < nums1.length; i++) {
            result[i] = map.get(nums1[i]);
        }
        return result;
    }
}