class5 哈希函数、哈希表和并查集（左程云左神算法 初级笔记 2018）

最新推荐文章于 2023-11-16 20:48:41 发布
最新推荐文章于 2023-11-16 20:48:41 发布
阅读量1.1k 收藏 5
点赞数
文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quanquanya/article/details/105870683
版权

class 5

DAY7

  • 认识哈希函数和哈希表
    • 哈希函数性质：1.输入域无穷大；2.输出域有穷大；3.若输入相等，则输出相等；4.若输入不相等，输出也可能相等（哈希碰撞）5.输出域上均匀分布
    • 哈希函数特征：1.与输入规律无关；2.哈希函数生成16位的码每一位都是相互独立的（因此利用一个哈希函数可造出很多哈希函数）
    • 哈希表的增删改查复杂度O(1)（哈希表的扩容复杂度log已n为底N，n为扩容的倍数，或者可以用离线扩容，因此哈希表的增删改查复杂度认为是O(1)）
    • 利用哈希函数做分流，处理大数据问题
package com.zuogod.java;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
 * @author quanquan
 * @create 2020-04-30-11:46
 */
public class HashMapTest {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap();
        map.put("zuo", "31");

        System.out.println(map.containsKey("zuo"));
        System.out.println(map.containsKey("chengyun"));
        System.out.println("=========================");

        System.out.println(map.get("zuo"));
        System.out.println(map.get("chengyun"));
        System.out.println("=========================");

        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println("=========================");

        System.out.println(map.remove("zuo"));
        System.out.println(map.containsKey("zuo"));
        System.out.println(map.get("zuo"));
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println("=========================");

        map.put("zuo", "31");
        System.out.println(map.get("zuo"));
        map.put("zuo", "32");
        System.out.println(map.get("zuo"));
        System.out.println("=========================");

        map.put("zuo", "31");
        map.put("cheng", "32");
        map.put("yun", "33");

        for (String key : map.keySet()) {
            System.out.println(key);
        }
        System.out.println("=========================");

        for (String values : map.values()) {
            System.out.println(values);
        }
        System.out.println("=========================");

        map.clear();
        map.put("A", "1");
        map.put("B", "2");
        map.put("C", "3");
        map.put("D", "1");
        map.put("E", "2");
        map.put("F", "3");
        map.put("G", "1");
        map.put("H", "2");
        map.put("I", "3");
        for (Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "," + value);
        }
        System.out.println("=========================");

        // you can not remove item in map when you use the iterator of map
//		 for(Entry<String,String> entry : map.entrySet()){
//			 if(!entry.getValue().equals("1")){
//				 map.remove(entry.getKey());
//			 }
//		 }

        // if you want to remove items, collect them first, then remove them by this way.
        List<String> removeKeys = new ArrayList<String>();
        for (Entry<String, String> entry : map.entrySet()) {
            if (!entry.getValue().equals("1")) {
                removeKeys.add(entry.getKey());
            }
        }
        for (String removeKey : removeKeys) {
            map.remove(removeKey);
        }
        for (Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "," + value);
        }
        System.out.println("=========================");

    }
}
  • 设计RandomPool结构
    【题目】 设计一种结构，在该结构中有如下三个功能：insert(key)：将某个key加入到该结构，做到不重复加入。delete(key)：将原本在结构中的某个key移除。 getRandom()：等概率随机返回结构中的任何一个key。
    【要求】 Insert、delete和getRandom方法的时间复杂度都是O(1)
package com.zuogod.java;

import java.util.HashMap;

/**
 * @author quanquan
 * @create 2020-04-30-13:24
 */
//使用两个哈希表
public class RandomPool {
    public static class Pool<K>{
        private HashMap<K, Integer> keyIndexMap;
        private HashMap<Integer, K> indexKeyMap;
        private int size;
        public Pool(){
            this.keyIndexMap = new HashMap<K, Integer>();
            this.indexKeyMap = new HashMap<Integer, K>();
            this.size = 0;
        }

        public void insert(K key){
            if (!this.keyIndexMap.containsKey(key)){
                this.keyIndexMap.put(key,this.size);
                this.indexKeyMap.put(this.size++,key);
            }
        }
        public void remove(K key){
            if(this.keyIndexMap.containsKey(key)){
                int deleteIndex = keyIndexMap.get(key);
                int lastIndex = --size;
                K lastKey = this.indexKeyMap.get(lastIndex);
                this.keyIndexMap.put(lastKey,deleteIndex);
                this.indexKeyMap.put(deleteIndex,lastKey);
                this.keyIndexMap.remove(key);
                this.indexKeyMap.remove(lastIndex);
            }
        }
        public K getRandom(){
            if (this.size == 0){
                return null;
            }
            int index = (int)(Math.random() * this.size); //0 ~ size-1
            return this.indexKeyMap.get(index);
        }
    }
    public static void main(String[] args) {
        Pool<String> pool = new Pool<String>();
        pool.insert("zuo");
        pool.insert("cheng");
        pool.insert("yun");

        pool.remove("zuo");
        System.out.println(pool.getRandom());
        System.out.println(pool.getRandom());
        System.out.println(pool.getRandom());
        System.out.println(pool.getRandom());
        System.out.println(pool.getRandom());
    }
}

  • 认识布隆过滤器

    • 某种类型的集合，但有失误率（不会把对的判错，但可能把不对的判对）

    • 比特类型的map

      数组大小：m = - (n * lnp) / (ln2)^2，其中，m为需要的bite位数，n为样本量，p为预期失误率；字节数为m/8

      哈希函数的个数：K = ln2 * m/n = 0.7 * m/n

      数组大小和哈希函数个数向上取整，真实失误率为：(1 - e ^ (- n*K/m))^K

  • 认识一致性哈希

    • 能够把数据迁移的代价变得很低，同时又负载均衡
    • 虚拟节点技术

  • 认识并查集结构

    • 功能：1.快速查询两个元素是否属于一个集合，2.两个元素所在集合合并在一起
package com.zuogod.java;

import java.util.HashMap;
import java.util.List;
import java.util.Stack;

public class UnionFind {

	public static class Node {
		// whatever you like，String\Int\Char...
	}

	public static class UnionFindSet {
		public HashMap<Node, Node> fatherMap; //Key : child, value : father
		public HashMap<Node, Integer> sizeMap; //某节点所在集合的节点数

		public UnionFindSet(List<Node> nodes) {
			makeSets(nodes);
		}

		public void makeSets(List<Node> nodes) {
			fatherMap = new HashMap<Node, Node>();
			sizeMap = new HashMap<Node, Integer>();
			for (Node node : nodes) {
				fatherMap.put(node, node);
				sizeMap.put(node, 1);
			}
		}

		private Node findHead(Node node) {
			//非递归
//			Stack<Node> stack = new Stack<>();
//			Node cur = node;
//			Node parent = fatherMap.get(cur);
//			while (cur != parent){
//				stack.push(cur);
//				cur = parent;
//				parent = fatherMap.get(cur);
//			}
//			while (!stack.isEmpty()){
//				fatherMap.put(stack.pop(),parent);
//			}
//			return parent;
			//递归
			Node father = fatherMap.get(node);
			if (father != node) {
				father = findHead(father);
			}
			fatherMap.put(node, father);
			return father;
		}
		
		public boolean isSameSet(Node a, Node b) {
			return findHead(a) == findHead(b);
		}

		public void union(Node a, Node b) {
			if (a == null || b == null) {
				return;
			}
			Node aHead = findHead(a);
			Node bHead = findHead(b);
			if (aHead != bHead) {
				int aSetSize= sizeMap.get(aHead);
				int bSetSize = sizeMap.get(bHead);
				if (aSetSize <= bSetSize) {
					fatherMap.put(aHead, bHead);
					sizeMap.put(bHead, aSetSize + bSetSize);
				} else {
					fatherMap.put(bHead, aHead);
					sizeMap.put(aHead, aSetSize + bSetSize);
				}
			}
		}

	}

	public static void main(String[] args) {

	}

}
  • 岛问题
    一个矩阵中只有0和1两种值，每个位置都可以和自己的上、下、左、右四个位置相连，如果有一片1连在一起，这个部分叫做一个岛，求一个矩阵中有多少个岛？
    举例：
    0 0 1 0 1 0
    1 1 1 0 1 0
    1 0 0 1 0 0
    0 0 0 0 0 0
    这个矩阵中有三个岛。
    • 利用并查集，可以做到并行，多CPU
package com.zuogod.java;

/**
 * 一般做法，单CPU
 * @author quanquan
 * @create 2020-04-30-21:37
 */
public class Islands {
    public static int islands(int[][] matrix){
        int M = matrix.length;  //矩阵的行数
        int N = matrix[0].length;  //矩阵的列数
        int res = 0;
        for (int i = 0; i<M; i++){
            for (int j = 0; j<N; j++){
                if (matrix[i][j] == 1){
                    res++;
                    infect(matrix,i,j,M,N);
                }
            }
        }
        return res;
    }
    public static void infect(int[][] matrix,int i,int j,int M,int N){
        if (i<0 || i>=M || j<0 || j>=N || matrix[i][j] == 0 || matrix[i][j] == 2){
            return;
        }
        matrix[i][j] = 2;
        infect(matrix,i+1,j,M,N);
        infect(matrix,i-1,j,M,N);
        infect(matrix,i,j+1,M,N);
        infect(matrix,i,j-1,M,N);
    }

    public static void main(String[] args) {
        int[][] m1 = {
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 1, 1, 1, 0, 1, 1, 1, 0 },
                { 0, 1, 1, 1, 0, 0, 0, 1, 0 },
                { 0, 1, 1, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 1, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, };
        System.out.println(islands(m1));
    }
}
quanquanya
关注
算法：哈希表
uncle_ll的博客
03-25 2765
哈希表简介 哈希表：也叫做散列表。是根据关键字和值（Key-Value）直接进行访问的数据结构。也就是说，它通过关键字 key 和一个映射函数 Hash(key) 计算出对应的值 value，然后把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数（散列函数），用于存放记录的数组叫做 哈希表（散列表）。 哈希表的关键思想是使用哈希函数，将键 key 和值 value 映射到对应表的某个区块中。可以将算法思想分为两个部分： 向哈希表中插入一个关键字：哈希函数决定该关键字的对应值应
【数据结构】 哈希表查找—哈希函数、哈希冲突
四季轮换叶，一路招摇胜
10-16 3507
将一组关键字映象到一个有限的、地址连续的地址集(区间)上，并以关键字在地址集中的象作为相应数据元素在表中的存储位置，如此构造所得的查找表称之为哈希表。
C算法-UT哈希+并查集
weixin_45554139的博客
06-02 429
leetcode面试题 17.07. 婴儿名字。之前写过一篇根本不算HASH的HASH，现在借鉴了各位大神的UT哈希方法，把这个题目理一理。 思路如下： 1、通过info存取names的关键信息，本质就是比names多了cnt及root信息，用处是记录最终的cnt信息，以及给团队赋值为最小字典序（char *root） 2、通过hash存取names的关键信息，用处是支撑synonyms元素的快速查找对应索引位置HASH_FIND，将两个索引进行并查集处理 小知识点一：对字符串分割 names = [“Jo
左程云算法 哈希函数
be_lxx1的博客
03-18 422
哈希函数是一个输入域无限但是输出域可以有限的函数 哈希函数/m就可以得到一个在（0，m-1）之间均匀分布的输出域 题目case1：右40亿个无符号整数，给1G的内存，找出出现次数最多的数字 这里使用常规的哈希表存储，会出现内存溢出的问题，表里面的数字都模100，把它存在哈希表中，再遍历这100个表里面的数据，内存就不会出现溢出。 哈希表在使用的时候可以认为其增删改查的复杂度为O（1），实际上为O（lng N） 题目case2: 设计RandomPoo l结构 【题目】 in it- 种结构 在
并查集、堆、Hash表
Nismilesucc的学习札记
02-22 300
一、并查集 二、堆 三、Hash表
Artwork(哈希表+并查集)
CHL的博客
08-10 1969
Description   A template for an artwork is a white grid of n × m squares. The artwork will be created by painting q horizontal and vertical black strokes. A stroke starts from square (x1, y1), ends a...
通过哈希表或者数组实现并查集
zr1996106的博客
03-01 345
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。 例如：在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合， 然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上
左程云leetcode-algorithm-and-data-structure:算法+数据结构=程序
06-30
数据结构和算法学习笔记 一、简介 1. 2. 3. 4. 5. 6. 二、数据结构 1. 二维数组（Array2D） 位数组（Bit Set） 静态数组（Fixed Size Array） 有序表（Ordered Array） 2. 队列（Queues） （后进先出） （先进先出）...
Python 算法基础篇之散列查找算法：哈希表、哈希集合、哈希映射
小蓝枣的博客
07-19 1164
散列查找算法是一种高效的查找技术，通过散列函数将键映射到数组的索引位置，实现快速的查找、插入和删除操作。本篇博客将介绍散列查找算法的三种常见应用：哈希表、哈希集合和哈希映射，并通过实例代码演示它们的应用。
MIT算法导论公开课之课程笔记 7.哈希表.rar
07-06
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。在MIT的算法导论公开课...这份笔记是学习哈希表理论和实践的宝贵资源，有助于深入理解这一核心算法概念，并提升解决实际问题的能力。
算法与数据结构——算法基础——哈希（java）（左程云b站课程笔记总结）
Borslav的博客
06-23 314
算法与数据结构——哈希（java）
算法与数据结构——并查集（java）（b站左程云课程笔记总结）
Borslav的博客
06-23 360
算法与数据结构——并查集（java）
集合-并查集与hash表
qq_37448192的博客
01-13 210
主要用于自己学习的，别学。
算法学习05:哈希&并查集
ncepu_Chen的博客
03-15 566
算法学习05:哈希认识哈希函数和哈希表设计RandomPool结构 认识哈希函数和哈希表 经典哈希函数: 输入域无穷大的,输出域有穷尽的, 输入参数固定时,返回值一定是一样的 输入值不同时,有可能得到相同的返回值,(哈希碰撞) 哈希函数的离散性:给我很多不同的书的话,我将在整个s域上均匀返回其输出值 设计RandomPool结构 【题目】 设计一种结构，在该结构中有如下三个功能： insert(k...
哈希——并查集结构
weixin_30640291的博客
04-26 141
并查集解决的问题：（速度快） 1.非常快的检查两个元素是否属于一个集合 isSameSet(A, B) 2.将两个元素各自所在的集合，合并在一起 union(A, B) 合并的是A,B所在的集合，而不是单纯的合并A和B 代表结点：指向自己的结点 初始化时，要有所有的样本结点 2是代表结点 4是代表结点 isSameSet(A, B) 查找A,B的上面的结点，知道找...
哈希3：认识并查集
qq_43091156的博客
03-26 303
并查集： 并查集主要有两个作用。1：它可以查询两个元素A和B是不是同一个集合里面的。2：它可以把A和B两个元素所在的集合合并起来，注意是两个元素所在的集合，而不是两个元素。使用并查集的时候要一次性把数据全部输入，不支持动态的变化。 下面来说一下实现并查集的结构： 使用这样一种方式，假设每一个元素都是自己的代表节点，用代表节点表示集合。 合并时：那个集合的元素更少，就挂在元素多的那个集合下面 查...
左神基础班 - 并查集
木剑温华 的 博客
03-23 661
这里要注意，我们有哈希表的时候，自己定义了Node，此时要定义该Node的哈希值怎么计算。 #include<iostream> #include<unordered_map> using namespace std; struct Node{ char c; //在并查集的 union_函数中用到了Node类型的比较操作，所以得自己重新定义 bool opera...
Leetcode|并查集+哈希表|721. 账户合并
SL_World的博客
06-30 241
1 并查集 + 双哈希表 此处要用两个哈希表，功能分别为 存储每个去重邮箱到用户ID的映射，以①在并查集union前帮助并查集判断两个重复邮箱是否同一人；②在并查集union后作为输入查找根节点用户ID，然后添加到每个用户ID到所属邮箱列表的映射 存储每个用户ID到所属邮箱列表的映射 class UnionFind { public: int count; vector<int> parent, size; UnionFind(int n) { .
【左程云算法全讲11】贪心算法 & 并查集
最新发布
qq_43840665的博客
11-16 587
系列综述：💞目的：本系列是个人整理为了秋招面试的，整理期间苛求每个知识点，平衡理解简易度与深入程度。🥰来源：材料主要源于进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证。🤭结语：如果有帮到你的地方，就和！！🌈。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值