Map、Set、二叉搜索树及哈希冲突解决

最新推荐文章于 2024-06-07 18:39:02 发布
最新推荐文章于 2024-06-07 18:39:02 发布
阅读量375 收藏
点赞数
分类专栏： 语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42031380/article/details/105420121
版权

在这里插入图片描述
Map和Set:作用------用来帮助用户进行搜索的容器 || 数据结构
用来搜索的集合类
查找方式：
1、顺序查找：----->O（N）
2、二分查找：----->要求：序列必须是有序的----->O（logN）
静态类型查找：查找的过程中，不会再改变数据的结构----->不会再插入和删除
Map和Set:动态查找

Map和Set：存储元素的类型：
Map:
1、Map是一个接口，没有继承自Collecction
2、Map中存储的是一个k-v结构的键值对，键值对中的key必须要唯一（key不能重复），V是可以重复的
2、所谓的k-v结构，实际就是新定义的一种类型Entry，该类型是Map内定义的，该接口包含有k,v

Map的常用方法：
在这里插入图片描述

Map的使用：
注意：Map是一个接口，必须使用TreeMap或HashMap来进行实例化
在这里插入图片描述
Map代码测试：

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapTest {
    public static void testTreeMap(){
        Map<String, String> m1 = new TreeMap<>();
        m1.put("peach", "桃子");
        m1.put("orange", "橘子");
        m1.put("apple", "苹果");
        System.out.println(m1.size());

        //验证key是否可以重复
        //如果key不存在，将该key-value组成的键值对直接插入
        //如果key存在，使用value替换原key所对应的value
        //在插入key-value期间，Map会保证key是一个有序的序列
        //延伸：插入期间肯定要对key进行比较大小；
        //延伸：如果key是自定义类型的元素，该类的对象必须要能比较大小--->实现Comparable接口Comparator
        //返回值：如果key不存在，将键值对插入，返回null
        //        如果key存在，用value覆盖，返回value的值
        m1.put("orange", "橙子");
        System.out.println(m1.size());
        System.out.println(m1);

        //key是一定不能为空的，如果为空会抛出NullPointerException--->原因是要进行key的比较
        //m1.put(null, "无名");

        //value可以为空null
        m1.put("banana", null);
        System.out.println(m1.size());
        System.out.println(m1);

        //get(key)
        //如果key存在，就返回与key对应的value;
        //如果key不存在，就返回null
        //如果key为null，就抛出空指针异常
        System.out.println(m1.get("apple"));
        System.out.println(m1.get("watermelon"));
        //System.out.println(m1.get(null));

        System.out.println(m1.getOrDefault("apple", "苹果手机"));
        System.out.println(m1.getOrDefault("watermelon", "西瓜"));
        System.out.println(m1.size());

        //remove(key)，将Map中key所对应的键值对删除掉
        //如果key存在，删除该键值对，然后返回该键值对中的value
        //如果key不存在，直接返回null


        //注意:时间复杂度----O（logN）----找key
        System.out.println(m1);
        System.out.println(m1.remove("banananana"));
        if(m1.containsKey("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1.remove("banana"));
        if(m1.containsKey("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1);

        //注意:时间复杂度----O（N）----找value实际要遍历
        System.out.println(m1);
        System.out.println(m1.remove("banananana"));
        if(m1.containsValue("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1.remove("banana"));
        if(m1.containsValue("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1);

        //打印所有的key
        //keySet()将Map中的所有key放在set中返回
        for (String s : m1.keySet()){
            System.out.print(s + " ");
        }
        System.out.println();

        //打印所有的value
        for (String s : m1.values()){
            System.out.print(s + " ");
        }
        System.out.println();

        for (Map.Entry<String, String> e : m1.entrySet()){
            System.out.print(e.getKey() + "---->" +e.getValue());
        }
        System.out.println();

    }
    public static void testHashMap(){
        Map<String, String> m1 = new HashMap<>();
        m1.put("peach", "桃子");
        m1.put("orange", "橘子");
        m1.put("apple", "苹果");
        System.out.println(m1.size());

        //验证key是否可以重复
        //如果key不存在，将该key-value组成的键值对直接插入
        //如果key存在，使用value替换原key所对应的value
        //在插入key-value期间，Map会保证key是一个有序的序列
        //延伸：插入期间肯定要对key进行比较大小；
        //延伸：如果key是自定义类型的元素，该类的对象必须要能比较大小--->实现Comparable接口Comparator
        //返回值：如果key不存在，将键值对插入，返回null
        //        如果key存在，用value覆盖，返回value的值
        m1.put("orange", "橙子");
        System.out.println(m1.size());
        System.out.println(m1);

        //key是一定不能为空的，如果为空会抛出NullPointerException--->原因是要进行key的比较
        //m1.put(null, "无名");

        //value可以为空null
        m1.put("banana", null);
        System.out.println(m1.size());
        System.out.println(m1);

        //get(key)
        //如果key存在，就返回与key对应的value;
        //如果key不存在，就返回null
        //如果key为null，就抛出空指针异常
        System.out.println(m1.get("apple"));
        System.out.println(m1.get("watermelon"));
        //System.out.println(m1.get(null));

        System.out.println(m1.getOrDefault("apple", "苹果手机"));
        System.out.println(m1.getOrDefault("watermelon", "西瓜"));
        System.out.println(m1.size());

        //remove(key)，将Map中key所对应的键值对删除掉
        //如果key存在，删除该键值对，然后返回该键值对中的value
        //如果key不存在，直接返回null


        //注意:时间复杂度----O（logN）----找key
        System.out.println(m1);
        System.out.println(m1.remove("banananana"));
        if(m1.containsKey("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1.remove("banana"));
        if(m1.containsKey("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1);

        //注意:时间复杂度----O（N）----找value实际要遍历
        System.out.println(m1);
        System.out.println(m1.remove("banananana"));
        if(m1.containsValue("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1.remove("banana"));
        if(m1.containsValue("banana")){
            System.out.println("banana is in map");
        }else{
            System.out.println("banana is not in map");
        }
        System.out.println(m1);

        //打印所有的key
        //keySet()将Map中的所有key放在set中返回
        for (String s : m1.keySet()){
            System.out.print(s + " ");
        }
        System.out.println();

        //打印所有的value
        for (String s : m1.values()){
            System.out.print(s + " ");
        }
        System.out.println();

        for (Map.Entry<String, String> e : m1.entrySet()){
            System.out.print(e.getKey() + "---->" +e.getValue());
        }
        System.out.println();
    }
    public static void main(String[] args) {
        //testTreeMap();
        testHashMap();
    }
}

**Set：**是一个接口，该接口继承了Collection，该接口中只能存放K
注意：Set只能使用TreeSet和HashSet
Set里面的key是不能够重复的，TreeSet：去重 + 排序 HashSet去重

Set中元素的遍历：
----->迭代器：设计模式----->依次寻访容器中的元素，而又无需了解其底层数据结构或者无需暴露底层接口实现

Set代码测试：

	public static void testTreeSet(){
        Set<String> s = new TreeSet<>();
        System.out.println(s.add("orange"));
        System.out.println(s.add("peach"));
        System.out.println(s.add("apple"));
        System.out.println(s.size());

        System.out.println(s.add("apple"));
        System.out.println(s);

        if(s.contains("watermelon")){
            System.out.println("zai");
        }else{
            System.out.println("buzai");
        }

        if(s.contains("apple")){
            System.out.println("zai");
        }else{
            System.out.println("buzai");
        }

        //遍历：
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println(s.remove("watermelon"));
        System.out.println(s.remove("apple"));

        s.clear();
    }
    public static void testHashSet(){
        Set<String> s = new HashSet<>();
        System.out.println(s.add("orange"));
        System.out.println(s.add("peach"));
        System.out.println(s.add("apple"));
        System.out.println(s.size());

        System.out.println(s.add("apple"));
        System.out.println(s);

        if(s.contains("watermelon")){
            System.out.println("zai");
        }else{
            System.out.println("buzai");
        }

        if(s.contains("apple")){
            System.out.println("zai");
        }else{
            System.out.println("buzai");
        }

        //遍历：
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println(s.remove("watermelon"));
        System.out.println(s.remove("apple"));

        s.clear();
    }
    public static void main(String[] args) {
        //testTreeMap();
        //testHashMap();
        //testTreeSet();
        testHashSet();
    }

面试题：
在这里插入图片描述

class Solution {
    public int singleNumber(int[] nums) {
        Set<Integer> s = new HashSet<>();
        for(int i = 0; i < nums.length; i++){
            if(!s.add(nums[i])){
                s.remove(nums[i]);
            }
        }
        Object[] o = s.toArray();
        return (int)o[0];
        
	//最佳方式是用下面异或的方式
        // int ret = 0;
        // for(int i = 0; i < nums.length; i++){
        //     ret ^= nums[i];
        // }
        // return ret;
    }
}

这里的add()方法解释如下：
在这里插入图片描述

在这里插入图片描述
思路：新的方法：使用HashMap

/*
// Definition for a Node.
class Node {
    public int val;
    public Node next;
    public Node random;

    public Node() {}

    public Node(int _val,Node _next,Node _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
class Solution {
    //使用HashMap解决：
    public Node copyRandomList(Node head){
        if(head == null){
            return null;
        }
        Map<Node, Node> m = new HashMap<>();
        Node node = head;
        while(node != null){
            m.put(node, new Node(node.val));
            node = node.next;
        }

        node = head;
        while(node != null){
            m.get(node).next = m.get(node.next);
            m.get(node).random = m.get(node.random);
            node = node.next;
        }

        return m.get(head);
    }
    // public Node copyRandomList(Node head) {
    //     if(head == null){
    //         return null;
    //     }
    //     //1、将新老结点串为一个链表
    //     Node cur = head;
    //     while(cur != null){
    //         Node node = new Node(cur.val,cur.next,null);
    //         Node tmp = cur.next;
    //         cur.next = node;
    //         cur = tmp;
    //     }
    //     //2、处理random指针域
    //     cur = head;
    //     while(cur != null){
    //         if(cur.random != null){
    //             cur.next.random = cur.random.next;
    //             cur = cur.next.next;
    //         }else{
    //             cur.next.random = null;
    //             cur = cur.next.next;
    //         }
    //     }
    //     //3、将老新链表拆开，返回新链表
    //     cur = head;
    //     Node newHead = cur.next;
    //     while(cur.next != null){
    //         Node tmp = cur.next;
    //         cur.next = tmp.next;
    //         cur = tmp;
    //     }
    //     return newHead;
    // }
}

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int numJewelsInStones(String J, String S) {
        //1、统计S中每个石头出现的次数
        Map<Character, Integer> m = new HashMap<>();
        for(int i = 0; i < S.length(); i++){
            char ch = S.charAt(i);
            int count = m.getOrDefault(ch, 0);
            m.put(ch, count + 1);
        } 
        //2、统计每个宝石出现的次数
        int jewelsCount = 0;
        for(int i = 0; i < J.length(); i++){
            jewelsCount += m.getOrDefault(J.charAt(i), 0);
        }
        return jewelsCount;
    }
}

在这里插入图片描述
在这里插入图片描述

import java.util.Scanner;
import java.util.Set;
import java.util.HashSet;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            //1、循环接收用户的输入
            String right = sc.nextLine().toUpperCase();
            String wrong = sc.nextLine().toUpperCase();
            //2、将wrong中的每个字符放到Set中
            //将正常的键保存在Set中
            Set<Character> s = new HashSet<>();
            for(int i = 0; i < wrong.length(); i++){
                s.add(wrong.charAt(i));
            }
            //3、检测right中每个字符是否在Set中出现过
            for(int i = 0; i < right.length(); i++){
                char ch = right.charAt(i);
                if(!s.contains(right.charAt(i))){
                    s.add(right.charAt(i));
                    System.out.print(right.charAt(i));
                }
            }
            System.out.println();
        }
    }
}

在这里插入图片描述
在这里插入图片描述

//比较器：默认情况下：
class CmpKV implements Comparator<Map.Entry<String, Integer>>{
    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2){
        if(o2.getValue() > o1.getValue()){
            return 1;
        }
        if(o2.getValue() == o1.getValue() && o1.getKey().compareTo(o2.getKey()) > 0){
            return 1;
        }
        if(o2.getValue() == o1.getValue() && o1.getKey().compareTo(o2.getKey()) == 0){
            return 1;
        }
        return -1;
    }
}
class Solution {
    public List<String> topKFrequent(String[] words, int k) {
        //1、统计每个单词出现的次数
        Map<String, Integer> m = new HashMap<>();
        for(int i = 0; i < words.length; i++){
            m.put(words[i], m.getOrDefault(words[i], 0) + 1);
        }
        //2、创建一个优先级队列
        PriorityQueue<Map.Entry<String, Integer>> p = new PriorityQueue<>(new CmpKV());
        for(Map.Entry<String, Integer> e : m.entrySet()){
            p.offer(e);
        }
        List<String> lRet = new ArrayList<>(k);
        for(int i = 0; i < k; i++){
            lRet.add(p.poll().getKey());
        }
        return lRet;
    }
}

TreeMap的底层数据结构：红黑树
红黑树：首先红黑树是一颗二叉搜索树 + 增加结点的颜色限制以及性质约束----->保证：最长路径中结点个数一定不会超过最短路径中结点个数的两倍，就认为其近似平衡
虽然红黑树是近似平衡的二叉树，但是大量的使用表明：红黑树性能比AVL树高，红黑树的实现更加简单
在这里插入图片描述
性质：
1、每个节点不是红色就是黑色
2、根结点一定是黑色
3、没有连在一起的红色结点
4、每条路径中黑色结点个数一样
5、没用（所有叶子结点（指空节点（空引用））都是黑色的）
保证：最长路径中结点个数一定不会超过最短路径中结点个数的两倍 查找时间复杂度：O（logN）

二叉搜索树：
在这里插入图片描述
在这里插入图片描述
进行中序遍历---->可以得到一个有序的序列
树中最左侧节点一定是最小的节点，最右侧节点一定是最大的

a、二叉搜索树—>最主要的作用是用来进行搜索的

b、二叉搜索树插入：
0、空树—直接插入
1、找待插入元素在二叉搜索树中的位置并保存其双亲
如果找到该元素，则不插入，直接返回
否则：进行2
2、插入新节点

c、删除节点：
找待删除结点在树中的位置
没有找到—>直接返回
找到：继续往下
删除该结点cur
对cur的孩子分情况：（第1种情况可以与第2种或者第3中情况合并起来，一共为3种情况）
1、cur是一个叶子结点
2、cur只有右孩子
3、cur只有左孩子
4、cur左右孩子均有

二叉搜索树代码：

//binary search tree
public class BSTree {

    //静态内部类
    public static class BSTNode{
        BSTNode left = null;
        BSTNode right = null;
        int val;
        BSTNode(int val){
            this.val = val;
        }
    }

    private BSTNode root = null;

    //检测val是否在二叉搜索树中
    public boolean contains(int val){
        BSTNode cur = root;
        while(cur != null){
            if(val == cur.val){
                return true;
            }else if(val < cur.val){
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
        return false;
    }

    //将val插入二叉搜索树中，插入成功返回true，否则返回false
    public boolean put(int val){
        //空树
        if(root == null){
            root = new BSTNode(val);
            return true;
        }
        //非空，找待插入元素在二叉搜索树中的插入位置并保存其双亲
        BSTNode cur = root;
        BSTNode parent = null;
        while(cur != null){
            parent = cur;
            if(val < cur.val){
                cur = cur.left;
            }else if(val > cur.val){
                cur = cur.right;
            }else{
                return false;
            }
        }
        //找到待插入节点的位置--->插入新节点
        //将新节点插入到parent的左侧或者右侧
        cur = new BSTNode(val);
        if(val < parent.val){
            parent.left = cur;
        }else{
            parent.right = cur;
        }
        return true;
    }

    public void inOrder(){
        inOrder(root);
    }

    private void inOrder(BSTNode root){
        if(root != null){
            inOrder(root.left);
            System.out.println(root.val + " ");
            inOrder(root.right);
        }
    }

    //最左侧节点----最小的节点
    public int leftMost(){
        if(root == null){
            //抛异常--->空指针异常
        }
        BSTNode cur = root;
        while(cur.left != null){
            cur = cur.left;
        }
        return cur.val;
    }
    //最右侧节点----最大的节点
    public int rightMost(){
        if(root == null){
            //抛异常--->空指针异常
        }
        BSTNode cur = root;
        while(cur.right != null){
            cur = cur.right;
        }
        return cur.val;
    }

    boolean remove(int val){
        if(root == null){
            return false;
        }
        //树非空，找待删除节点在树中的位置
        BSTNode cur = root;
        BSTNode parent = null;
        while (cur != null){
            if(val == cur.val){
                break;
            }else if(val < cur.val){
                parent = cur;
                cur = cur.left;
            }else{
                parent = cur;
                cur = cur.right;
            }
        }
        //没有找到
        if(cur == null){
            return false;
        }
        //已经找到待删除的节点在树中的位置---删除该节点
        //删除节点
        //必须对cur的孩子节点分情况
        //1、cur没有孩子
        //2、cur只有左孩子
        //3、cur只有右孩子
        //4、cur左右孩子均有
        if(cur.left == null){
            //cur只有右孩子
            if(parent == null){
                //cur双亲不存在，cur就是根节点
                root = cur.right;
            }else{
                if(cur == parent.left){
                    parent.left = cur.right;
                }else{
                    parent.right = cur.right
                }
            }
        }else if(cur.right == null){
            //cur只有左孩子
            if(parent == null){
                root = cur.left;
            }else{
                if(cur == parent.left){
                    parent.left = cur.left;
                }else{
                    parent.right = cur.left;
                }
            }
        }else{
            //cur的左右孩子均存在
            //在cur子树中找一个替代的节点删除
            //方式一:在其右子树中找最小的节点:即最左侧节点
            //方式二:在其左子树中找最大的节点:即最右侧节点
            BSTNode del = cur.right;
            parent = cur;
            while(del.left != null){
                parent = del;
                del = del.left;
            }
            //替代节点找到
            cur.val = del.val;
            //删除替代节点
            if(del == parent.left){
                parent.left = del.right;
            }else{
                parent.right = del.right;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] array = {5, 3, 4, 1, 7, 8, 2, 6, 0, 9};
        BSTree t = new BSTree();
        for (int e : array) {
            t.put(e);
        }
        t.inOrder();
        System.out.println();
        System.out.println(t.leftMost());
        System.out.println(t.rightMost());
    }
}

在这里插入图片描述

面试问题：有一颗二叉搜索树，将该二叉搜索树转化为排序的双向链表？
双向链表有结点：next和prev(指向下一个和前一个结点)
二叉搜索树中有结点：left和right（指向左子树和右子树）
二叉搜索树---->按照中序遍历的规则来改变结点left和right引用的指向
约定：left指向比当前结点小的结点，right指向大的结点
在这里插入图片描述
1、找链表的首结点---->就是树中最小的结点---->就是树中最左侧的结点
2、按照中序遍历的规则来修改每个结点的左右孩子的指向
分析可知：每拿到一个结点----只能修改当前结点的左指针域—原因：因为按照中序规则进行遍历，肯定知道当前结点的前一个结点是哪个结点（因为其前一个结点刚刚遍历过），当前结点的后序还没有遍历。
假设：cur是当前结点
prev：来标记刚刚遍历过的结点
cur.left = prev;
cur.right----->无法操作
prev.right = cur;

BSTNode prev = null;//标记中序遍历刚刚遍历过的结点
    public BSTNode BSTree2DList(){
        if(root == null){
            return null;
        }
        //找树中最左侧的结点，即双向链表的头
        BSTNode head = root;
        while(head.left != null){
            head = head.left;
        }

        //2、修改每个结点的left和right的指向

        BSTree2DList(root);
        return head;
    }

    public void BSTree2DList(BSTNode root){
        if(root == null){
            return;
        }
        //转化根结点的左子树
        BSTree2DList(root.left);

        //转化根结点
        root.left = prev;
        if(prev != null){
            prev.right = root;
        }
        //用prev将刚刚遍历的结点保存起来
        prev = root;

        //转化根结点的右子树
        BSTree2DList(root.right);
    }

搜索：
1、循环遍历----->O（N）
2、二分查找，条件：序列必须有序---->O（logN）
3、如果不是有序---->可以将数据按照平衡二叉树的方式进行组织---->O（logN）
以上3种搜索的方式共同点：都要进行比较
哈希：（散列表）
而理想的查找方式可以不用进行比较，快速将数据找到
如果通过某种方式，能够将数据与其存储位置之间建立一一对应的关系

例如：数据集合{1，7，6，4，5，9}
在这里插入图片描述
在这里插入图片描述

哈希冲突解决-闭散列

解决哈希冲突问题采用闭散列，其中包括了线性探测和二次探测
在这里插入图片描述
在这里插入图片描述
闭散列最大的缺陷就是空间利用率比较低，是使用空间换时间的做法，这也是哈希的缺陷

哈希冲突解决-开散列（哈希桶）

在这里插入图片描述

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

//哈希桶----数组 + 链表实现的---->数组：可以帮助用户快速定位要将元素插入到哪个链表
//                                     来组织链表(不带头结点的单链)
//数组中存储的元素实际为结点的引用
public class HashBucket {
    public static class Node{
        int key;
        int value;
        Node next;
        public Node(int key, int value){
            this.key = key;
            this.value = value;
            next = null;
        }
    }

    //哈希桶中的成员数据
    Node[] table;
    int capacity;       //表格的容量---桶的个数
    int size;           //有效元素的个数
    double loadFactor = 0.75;//装载因子


    //保证哈希桶初识的容量至少为10个
    public HashBucket(int initCap){
        capacity = initCap;
        if(initCap < 10){
            capacity = 10;
        }
        table = new Node[capacity];
        size = 0;
    }

    public int put(int key, int value){

        resize();
        //1、通过哈希函数，计算key所在的桶号
        int bucketNo = hashFunc(key);

        //2、在bucketNo桶中检测key是否存在
        //检测方式:遍历链表
        Node cur = table[bucketNo];
        while(cur != null){
            if(cur.key == key){
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
            cur = cur.next;
        }

        //3、key不存在，将key-value插入到哈希桶中
        cur = new Node(key, value);
        cur.next = table[bucketNo];
        table[bucketNo] = cur;
        size++;
        return value;
    }

    //
    public boolean remove(int key){
        //1、通过哈希函数计算key的桶号
        int bucketNo = hashFunc(key);

        //2、在bucketNo桶中找key所对应的结点
        //找到后将该结点删除
        Node cur = table[bucketNo];
        Node prev = null;
        while(cur != null){
            if(cur.key == key){
                //找到与key所对应的结点，将该结点删除
                if(prev == null){
                    //删除的结点是第一个结点
                    table[bucketNo] = cur.next;
                }else{
                    //删除其他结点
                    prev.next = cur.next;
                }
                --size;
                return true;
            }else{
                cur = cur.next;
            }
        }
        return false;
    }

    //O(1)
    public boolean containsKey(int key){
        //1、计算key所在的桶号
        int bucketNo = hashFunc(key);

        //2、在bucketNo桶中找key
        Node cur = table[bucketNo];
        while(cur != null){
            if(cur.key == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    //O(n)
    public boolean containsValue(int value){
        //注意：哈希桶是根据key来计算哈希地址的
        //因此：找value，不能计算出value在哪个桶中
        //找value时，必须要遍历所有桶才行
        for(int bucketNo = 0; bucketNo < capacity; bucketNo++){
            Node cur = table[bucketNo];
            while(cur != null){
                if(cur.value == value){
                    return true;
                }
                cur = cur.next;
            }
        }
        return false;
    }

    public int size(){
        return size;
    }

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

    private void resize(){
        //装载因子超过0.75时按照2倍的方式进行扩容
        if(size * 10 / capacity > loadFactor * 10){
            int newCap = capacity * 2;
            Node[] newTable = new Node[capacity * 2];

            //将table中的结点搬移到newTable中
            for(int i = 0; i < capacity; i++){
                Node cur = table[i];

                //将table中i号桶所对应链表中所有的结点插入到newTable中
                while(cur != null){
                    table[i] = cur.next;

                    //将cur结点插入到newTable中
                    //1、计算cur在newTable中的桶号
                    //int bucketNo = hashFunc(cur.key);不行--->hashFunc里面用的是旧桶的容量
                    int bucketNo = cur.key % newCap;

                    //2、将cur插入到newTable中
                    cur.next = newTable[bucketNo];
                    newTable[bucketNo] = cur;

                    //取table中i号桶的下一个结点
                    cur = table[i];
                }
            }
            table = newTable;
            capacity = newCap;
        }
    }
    private int hashFunc(int key){
        return key % capacity;
    }

    public void printHashBucket(){
        for(int bucketNo = 0; bucketNo < capacity; bucketNo++){
            System.out.printf("table[%d]", bucketNo);
            Node cur = table[bucketNo];
            while(cur != null){
                System.out.print("[" + cur.key + "," + cur.value + "]--->");
                cur = cur.next;
            }
            System.out.println("null");
        }
    }

    public static void main(String[] args) {
        HashBucket ht = new HashBucket(5);
        ht.put(1, 1);
        ht.put(11, 11);
        ht.put(2, 2);
        ht.put(22, 22);
        ht.put(6, 6);
        ht.put(5, 5);
        ht.put(51, 51);
        ht.put(8, 8);
        System.out.println(ht.size());
        ht.printHashBucket();
        //验证扩容
        ht.put(3, 3);
        ht.printHashBucket();

        System.out.println(ht.containsKey(5));
        System.out.println(ht.containsValue(15));

        ht.remove(5);
        System.out.println(ht.containsKey(5));
        ht.printHashBucket();

        //Map<String, String> m = new HashMap<>();
    }
}

看源代码文档：好好的去看 里面每个方法基本都加了注释了 大家把主要的思想搞清楚就可以了 比如：hashMap为什么要按照2的n次幂扩容，为什么必须要重写hashCode和equals方法？是不是线程安全的 在多线程下扩容会造成什么问题 这些文档中都有介绍，都是面试常考的问题，把原理搞清楚了 面试期间HashMap基本难不倒你

Java8: HashMap

1、哈希桶默认容量为16
2、哈希桶的最大容量为2^30
3、如果哈希桶中一条链表中结点个数比较多，HashMap会将链表转换为红黑树
条件：哈希表格桶的容量超过64 && 链表中结点个数超过8
4、如果红黑树中结点个数小于6个时，红黑树会退化为链表
5、HashMap中链表对应的结点的结构：实现了Map.Entry接口
一个结点： hash:哈希值
key
value
next
6、哈希函数

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

如果key不为空，首先让key调用自己的hashCode的方法，拿到key的哈希码----->如果是自定义类型：该类的hashCode方法必须重写
哈希值具体的计算方式：将h的高16位与低16位异或
如果哈希表的容量没有超过2^16次方，高位全部是0
如果哈希表的容量超过2^16时，高位不一定是0—>让高16位与低16位进行异或

7、扩容时机
capacity * factor ----> 16 * 0.75 ----> 12

蓝色海洋oO
关注
专栏目录
解决hash冲突的四种方法
渔舟的博客
09-24 1644
解决hash冲突的四种方法
搜索树与哈希表详解
dddddrrrzz的博客
02-27 1250
目录一、搜索树1.1 概念1.2 查找1.3 插入1.4 删除1.5 性能分析1.6 与java集类的关系二、哈希表2.1 概念总结 一、搜索树 1.1 概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 如： 1.2 查找 若根节点不为空: 如果根节点==查找key 返回当前节点； 如果根节点 >查找key在
【习作】用二叉树处理溢出的哈希表
arkrszji40041的博客
12-28 332
问题综述 这是我在学习数据结构时遇到的一个习题，要求使用二叉树处理存数冲突，而不是线性探查表使用的顺序向下存的方法。觉得有点意思，所以放上来。很显然，使用二叉树不会出现溢出的方法，而且也能享受二叉树的优秀搜索、插入、删除性能。 借物表 二叉树使用std::set hash函数采用std::hash 代码参考Sartaj Sahni的《数据结构、算法与应用》 ...
Java散列表，树对应的容器类，hashmap如何解决冲突
weixin_34387284的博客
04-30 181
为什么80%的码农都做不了架构师？>>> ...
构造二叉查找树、哈希表、哈希冲突、字符匹配BF暴力破解
day day no bug
02-07 240
1. 二叉查找树 左右子树不为空，则左右子树所有结点都小于左右起始结点 其左右子树都为二叉树 2. 构造二叉查找树 2.1方法 第一个元素为根 从第二个元素开始，逐个按照小往左大往右的原则插入至叶子结点 每次新插入的元素一定位于叶子 2.2 AVL树 从序列{1，2，3…n}依次插入构造出二叉查找树唱什么样？退化为单链表，查找目标值的平均时间复杂度位O(n)。 AVL树：尽量保持一颗二查树的平衡性。 每一个结点的左右子树的高度差 <= 1 方法：如果插入一个结点导致树的不平衡，通过旋转调整回
二叉排序树与 set、map
WANGHAOXIN364的博客
03-26 1495
前置知识：二叉树的概念及性质 为了保证学习效果，请保证已经掌握前置知识之后，再来学习本章节！ 学习目标 理解二叉排序树的概念 理解二叉排序树的查找、插入、删除、构建和简单平衡的过程 掌握 STL 的容器map、set的使用方法及其用途 二叉排序树的概念 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree）、二叉搜索树，是指一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值。 若它的右...
Java - Map和Set（搜索树、哈希表）
旧时言的博客
02-20 1052
本节目标 掌握 Map/Set 及实际实现类 HashMap/TreeMap/HashSet/TreeSet 的使用 掌握 TreeMap 和 TreeSet 背后的数据结构搜索树的原理和简单实现 掌握 HashMap 和 HashSet 背后的数据结构哈希表的原理和简单实现 1. 搜索 1.1 概念及场景 Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的 搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复
data-structures:队列、栈、链表、树、图、集合、哈希表、二叉搜索树的实现
07-04
本文将详细探讨标题中提及的几种基本数据结构：队列、栈、链表、树、图、集合、哈希表以及二叉搜索树，并以JavaScript为编程语言来阐述其实现。 1. **队列**： 队列是一种先进先出（FIFO）的数据结构。在...
二叉搜索树
weixin_45926367的博客
05-15 603
二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 二叉搜索树的定义 二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 下面是一个二叉搜索树的例子： 这篇文章之后，我们提供了一个习题来让你验证一个树是否是二叉搜索树。 你可以运用我们上述提到的性质来判断
Java中散列表、树所对应的容器类。HashMap如何解决hash冲突的
07-08 229
散列表（哈希表）对应的容器 HashMap、hashset、HashTable、concurrentHashMap 树对应的容器 treemap、treeset 什么是Hash冲突 两个不同的 key 计算出来的 hashcode 值相同。 解决方法 开放定址法 key=(f(key)+di...
哈希冲突
m0_46657493的博客
05-16 401
在保存元素不是固定范围时，哈希冲突有可能避免吗？ 不能避免；因为存储的元素范围远远大于数组的长度 但可以尽可能的减少冲突，那么如何减少？ 数组大小用素数（Java中不太用） 当 index = hashValue % arr.length 时 hash函数要尽可能的均匀 如何解决hash冲突？ 线性探测 拉链法（Java的hashMap选用这种） 1. 线性探测法解决hash冲突 例： int[] arr = new int[11] 存放元素：7，31，5，8，...
Java集合 Map List 相关问题
weixin_42669555的博客
08-08 257
一、HashMap中如果hash冲突怎么办 hash值冲突是发生在put()时，从源码可以看出，hash值是通过hash(key.hashCode())来获取的，当put的元素越来越多时，难免或出现不同的key产生相同的hash值问题，也即是hash冲突，当拿到一个hash值，通过indexFor(hash,table.length)获取数组下标，先查询是否存在该hash值，若...
Java散列表，树对应的容器类，Hashmap如何解决冲突及一些基本性质
小张Python
06-22 284
Java散列表 Hashmap、hashtable、concurrentHashMap、hashset； 树： treemap、treeset、hashset treeset 继承自 treemap，hashset 继承自 hashmap ； 性能分析： Map 是 Java 中的接口，Map.Entry 是 Map 的一个内部接口 Map 提供了一些常用方法，例如 keySet()、entrySet() 方法等； Entry: key 和 value的组合，即为一个映射项<K,V> Treem
HashMap Hash碰撞 treemap
myccsdn的专栏
08-06 848
HashMap中，如果某个桶中的记录过 大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。它是如何工作 的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升 级成一个二叉树
HashMap，哈希冲突，HashSet
laoXingyao的博客
07-27 3623
1. HashMap HashMap是键值对key-value，key不能重复，是利用hash算法实现的。 HashMap的工作原理: 我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它数据结构：最左侧是一个数组，数组中的每一个元素都是一个链表，链表的每一个元素都...
Hash算法 平衡二叉树（调整平衡）
weixin_54401017的博客
08-30 255
给定一串数字 10 50 60 1 5 .判断 7 在不在里面简单的Hash思想因为最大的数是60，所以定义一个数组长度为int a[] = new int[61]
Map和List的对象是否是同一对象（并说明hash冲突）
笑话的专栏
07-11 536
先上代码，根据结果说明： public static void testList(){ Map map = new HashMap<>(); for(int i = 0; i<10;i++){ List list = new ArrayList<>(); list.add("1"); map.put(String.valueOf(i), list); System
什么是哈希冲突？如何解决哈希冲突？HashMap和TreeMap之间的区别？
最新发布
Shine0115的博客
06-07 889
如下图：当通过相同的哈希算法计算44的哈希地址时，44的哈希地址就和4的哈希地址冲突了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值