当前位置： 首页 > wzjs >正文

温州网站建设服务中心软件开发和网页设计哪个好

wzjs 2025/8/30 12:44:30
温州网站建设服务中心,软件开发和网页设计哪个好,一键建站网站,网站注销主体hash和队列青铜挑战 hash和队列基本知识 hash 哈希（Hash）是将任意长度的输入（通常是字符串）通过哈希函数映射为固定长度的输出（哈希值）。它广泛应用于数据存储、数据查找、密码学等领域。在Java中&#x…

hash和队列青铜挑战

hash和队列基本知识

hash

 哈希（Hash）是将任意长度的输入（通常是字符串）通过哈希函数映射为固定长度的输出（哈希值）。它广泛应用于数据存储、数据查找、密码学等领域。在Java中，常见的哈希相关类包括HashMap、HashSet以及Hashtable等。

哈希的基本原理

哈希函数的作用是将输入数据映射到一个固定大小的值。理想情况下，哈希函数应该：

  1. 不同的输入应该尽量映射到不同的哈希值（减少哈希冲突）。
  2. 输入数据的微小变化应该导致哈希值的大幅度变化。

Java中HashMap的基本使用

在Java中，HashMap是基于哈希表实现的，它提供了一个存储键值对的容器，通过哈希值定位存储位置，通常具有很快的查找和插入速度。

下面是一个简单的HashMap使用示例：

import java.util.HashMap;public class HashMapExample {public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>(); map.put("apple", 1);map.put("banana", 2);map.put("cherry", 3);//获取值System.out.println("The value for 'apple' is " + map.get("apple"));//遍历HashMapfor(String key : map.keySet()){System.out.println(key + " => " + map.get(key));}//判断HashMap是否包含某个键if (map.containsKey("banana")) {System.out.println("Banana exists.");}//删除键值对map.remove("cherry");System.out.println("'cherry' exists? " + map.containsKey("cherry"));}
}
哈希存储

哈希存储（或哈希表存储）是利用哈希函数将数据映射到一个固定大小的表格中。在哈希表中，数据被存储在“桶”（bucket）中，每个桶有一个对应的索引，这个索引是由哈希函数生成的。
哈希函数：哈希函数将一个输入（例如，一个字符串）映射为一个固定大小的输出（哈希值）。这个哈希值通常是整数类型，作为数组或链表的索引。

例如：

  • 输入 apple，哈希函数可能返回值 3，表示将 apple 存储在数组的第3个位置。
  • 输入 banana，哈希函数可能返回值 5，表示将 banana 存储在数组的第5个位置。

哈希表的基本操作：

  • 插入： 哈希函数会根据键计算出对应的索引，然后将值存储在该索引处。
  • 查找： 查找时，哈希函数根据键计算索引，然后直接访问该索引位置的值。
  • 删除： 删除时，哈希函数计算索引并删除该位置的值。
哈希冲突

哈希冲突发生在两个不同的键经过哈希函数计算后，得到了相同的哈希值。这意味着它们被映射到了哈希表中的相同位置（桶），但是每个位置只能存放一个值，因此就产生了冲突。

假设我们有如下的哈希表，大小为5（索引范围为0到4）：

[ ] [ ] [ ] [ ] [ ]

我们要插入两个不同的键：apple 和 banana。假设哈希函数将 apple 映射到索引 2，将 banana 映射到索引 2（由于哈希函数的特性，它们得到了相同的哈希值），此时就会发生哈希冲突。

为了解决哈希冲突，我们通常采用以下几种常见的解决方法。

解决哈希冲突的方法
1. 链式法（Chaining）

链式法是最常见的解决哈希冲突的方式。它为每个哈希表的桶（索引位置）创建一个链表或其他容器，所有映射到同一位置的键值对都保存在该链表中。

示例： 假设我们使用链表存储冲突的元素，当发生冲突时，apple 和 banana 将被存储在索引 2 的链表中：

[ ] [ ] [apple -> banana] [ ] [ ]

  • apple 和 banana 都被存储在索引为 2 的链表中，链表中的节点可以存储多个键值对。
  • 查找时，如果两个键哈希到同一个位置，程序会遍历该位置的链表查找正确的键值对。
2. 开放地址法（Open Addressing）

开放地址法是将冲突的元素存储到哈希表的其他位置。它的关键思想是，如果发生冲突，哈希表会寻找下一个空的桶来存储数据。

开放地址法有几种具体的实现方式，最常见的是线性探测和二次探测。

  • 线性探测： 如果当前位置已经被占用，程序就尝试下一个位置（即 index + 1），直到找到空位。

    例如，如果apple哈希到索引2，并且该位置已经被占用（banana），那么程序会尝试将apple存放到3，如果3也被占用，则尝试4，以此类推。

  • 二次探测： 与线性探测不同，二次探测会按照固定的步长（通常是平方数）来寻找下一个空桶。例如，如果冲突发生在位置 i，那么下一个查找的位置会是 i+1^2，如果仍然冲突，再尝试 i+2^2。

示例： 假设哈希表大小为 5，我们有以下两个键：

  • apple 哈希到位置 2。
  • banana 哈希到位置 2（发生冲突）。

使用开放地址法时，如果位置 2 已经被 apple 占用，程序就会查找下一个空位置来存储 banana，例如位置 3 或 4。

3. 再哈希法（Rehashing）

再哈希法是指，当哈希表中的元素超过某个负载因子（比如 0.75）时，重新调整哈希表的大小，并将所有现有元素重新计算哈希值并放入新表中。这通常用于动态扩展哈希表。

4. Java中的哈希冲突处理

在Java的HashMap中，哈希冲突是通过链式法来解决的。如果多个键的哈希值相同，HashMap会将这些键值对存储在同一个桶的链表中。通常，HashMap会将链表转换为红黑树（如果链表的长度超过一定阈值），从而提高查找效率。

总结
  • 哈希存储是通过哈希函数将数据映射到固定大小的数组（或桶）中，使得查找和插入操作的时间复杂度接近O(1)。
  • 哈希冲突是指两个或更多的键经过哈希计算后，得到相同的哈希值，导致它们被存储在相同的位置。

队列

队列（Queue）是一种典型的线性数据结构，遵循先进先出（FIFO, First In First Out）的原则。也就是说，最先插入队列的元素会最先被移除。队列在许多场景中都有广泛的应用，比如任务调度、进程管理、网络缓冲区等。

队列的基本操作

队列主要有以下几个基本操作：

  1. 入队（enqueue）： 向队列的尾部添加元素。
  2. 出队（dequeue）： 从队列的头部移除元素。
  3. 查看队头元素（peek/front）： 获取队列头部的元素，但不移除它。
  4. 判断队列是否为空（isEmpty）： 检查队列是否包含元素。
  5. 获取队列的大小（size）： 获取队列中元素的个数。

队列的特点

  • FIFO（先进先出）： 队列中的元素按顺序排队，最早进入队列的元素会最先出队。
  • 动态增长或固定大小： 队列可以是动态大小的（例如通过链表实现），也可以是固定大小的（例如通过数组实现）。

队列的实现方式

  1. 数组实现： 利用数组来实现队列，可以通过索引来管理队头和队尾。
  2. 链表实现： 使用链表来实现队列，节点之间通过指针连接。

Java中的队列

在Java中，队列通常由Queue接口来定义，常用的实现类有LinkedList、ArrayDeque等。Java还提供了线程安全的队列实现类，例如ConcurrentLinkedQueue。

以下是一个简单的队列实现示例，使用LinkedList来实现队列：

import java.util.LinkedList;
import java.util.Queue;public class QueueExample {public static void main(String[] args) {//创建一个队列Queue<String> queue = new LinkedList<>();//入队queue.offer("apple");queue.offer("banana");queue.offer("cherry");//查看队头元素System.out.println("Front element: " + queue.peek());//出队System.out.println("Dequeued: " + queue.poll());//打印System.out.println(queue);//判断是否为空if (!queue.isEmpty()) {System.out.println("Not empty.");}//获取队列大小System.out.println("Queue size: " + queue.size());}
}

hash和队列白银挑战

队列的经典问题

用两个栈实现队列

leetcode232

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

解法：

  1. 栈1（stackIn）：用来处理 push 操作，将元素推入栈的顶部。
  2. 栈2（stackOut）：用来处理 pop 和 peek 操作。为了保持队列的先进先出特性，我们从栈2中弹出元素。但是栈2中的元素顺序是后进先出，为了实现队列的先进先出，需要先将栈1中的所有元素倒入栈2。
详细步骤
  • push(x)：直接将元素 x 推入 stackIn。
  • pop()：
    • 如果 stackOut 为空，则将 stackIn 中的所有元素逐个弹出并推入 stackOut。这样，栈1中的元素倒入栈2时，顺序就会反转，从而模拟队列的先进先出。
    • 然后从 stackOut 中弹出并返回元素。
  • peek()：返回 stackOut 的顶部元素。如果 stackOut 为空，则先将 stackIn 中的元素倒入 stackOut，再返回 stackOut 的顶部元素。
  • empty()：检查 stackIn 和 stackOut 是否都为空。如果两个栈都为空，则队列为空。
import java.util.Stack;public class MyQueue {private Stack<Integer> stackIn;private Stack<Integer> stackOut;public MyQueue(){stackIn = new Stack<>();stackOut = new Stack<>();}//1. 直接将元素推入stackIn，将元素推到队列的末尾public void push(int x){stackIn.push(x);}//2. 将 stackIn 中的所有元素转移到 stackOut，然后从 stackOut 弹出栈顶元素并返回public int pop(){if (stackOut.isEmpty()) {while (!stackIn.isEmpty()) {stackOut.push(stackIn.pop());}}return stackOut.pop();}//3. 返回栈顶元素但不弹出public int peek(){if (stackOut.isEmpty()) {while (!stackIn.isEmpty()) {stackOut.push(stackIn.pop());}}return stackOut.peek();}//4. 判断队列是否为空public boolean empty(){return stackIn.isEmpty() && stackOut.isEmpty();}
}

用两个队列实现栈

leetcode225

要使用两个队列来实现一个后入先出（LIFO）的栈，我们需要通过队列的先进先出（FIFO）特性来模拟栈的后进先出行为。队列是先进先出，而栈是后进先出，所以我们可以通过在 push 和 pop 操作中对队列的操作顺序进行巧妙安排来实现栈的行为。

  1. 队列1（queueIn）：用来处理 push 操作，存储元素。
  2. 队列2（queueOut）：用来处理 pop 和 top 操作。
详细步骤

  • push(x)：

    • 将元素 x 放入 queueIn。这个操作时间复杂度是 O(1)。

  • pop()：

    • 将 queueIn 中的元素逐个转移到 queueOut 中，直到 queueIn 中只剩下一个元素，这个元素就是栈顶元素。
    • 弹出 queueIn 中的最后一个元素。
    • 然后交换 queueIn 和 queueOut，使得 queueIn 继续保存新的元素。
    • 这个操作的时间复杂度是 O(n)，因为可能需要将所有元素从 queueIn 移动到 queueOut。

  • top()：

    • 类似于 pop()，我们将 queueIn 中的元素逐个转移到 queueOut 中，直到只剩下一个元素。
    • 返回该元素，但不移除它。
    • 然后交换 queueIn 和 queueOut。
    • 这个操作的时间复杂度也是 O(n)。

  • empty()：

    • 直接检查 queueIn 和 queueOut 是否都为空。如果都为空，则栈为空，返回 true，否则返回 false。这个操作是 O(1) 时间复杂度。
import java.util.LinkedList;
import java.util.Queue;public class MyStack {private Queue<Integer> queueIn;private Queue<Integer> queueOut;public MyStack(){queueIn = new LinkedList<>();queueOut = new LinkedList<>();}//将元素推入栈顶public void push(int x){queueIn.offer(x);}//移除并返回栈顶元素public int pop(){while (queueIn.size() > 1) {queueOut.offer(queueIn.poll());}// 返回栈顶元素，即 queueIn 中剩下的那个元素int topElement = queueIn.poll();Queue<Integer> temp = queueIn;queueIn = queueOut;queueOut = temp;return topElement;}//返回栈顶元素，不移除public int top(){while (queueIn.size() > 1) {queueOut.offer(queueIn.poll());}// 返回栈顶元素，即 queueIn 中剩下的那个元素int topElement = queueIn.peek();// 将剩余的那个元素再次放回 queueOutqueueOut.offer(queueIn.poll());Queue<Integer> temp = queueIn;queueIn = queueOut;queueOut = temp;return topElement;}//判断栈是否为空public boolean empty(){return queueIn.isEmpty() && queueOut.isEmpty();}
}

hash和队列黄金挑战

LRU的设计与实现

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存。

int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。

void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该逐出最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

解法：

为了设计一个满足 LRU (最近最少使用) 缓存的类，可以使用 双向链表 和 哈希表 的组合来确保以下几点：

  1. 双向链表：可以支持 O(1) 时间复杂度的插入和删除操作。
  2. 哈希表：可以支持 O(1) 时间复杂度的查找操作。

具体思路：

  • 使用双向链表来维护缓存的顺序，链表的头部表示最近使用的元素，尾部表示最久未使用的元素。
  • 使用哈希表存储 key 和链表节点的映射，以便 O(1) 查找。
具体步骤
  1. get(key)：查找哈希表中的键。如果找到，返回值并将该节点移到链表头部。如果未找到，返回 -1。
  2. put(key, value)：如果键存在，更新值并将节点移到链表头部。如果键不存在，创建一个新节点，插入到链表头部，并检查是否超过容量，如果超过则移除尾部节点（即最久未使用的节点）。
import java.lang.classfile.components.ClassPrinter.Node;
import java.util.HashMap;
import java.util.Map;public class LRUCache {private final int capacity;private final Map<Integer, Node> map = new HashMap<>();private Node head = null;private Node tail = null;public LRUCache(int capacity){this.capacity = capacity;}public int get(int key){if (!map.containsKey(key)) {return -1;}Node node = map.get(key);// 移除该节点，因为它即将被移动到链表头部removeNode(node);//调用 setHead(node) 将该节点放到链表的头部setHead(node);return node.value;}public void put(int key, int value){// 如果已存在，则更新其值并移到头部if (map.containsKey(key)) {Node node = map.get(key);node.value = value;removeNode(node);setHead(node);} else {// 否则创建新的节点if (map.size() >= capacity) {  // 超过容量时移除尾部节点map.remove(tail.key);removeNode(tail);}Node newNode = new Node(key, value);map.put(key, newNode);setHead(newNode);}}public void removeNode(Node node){if (node.prev != null) { //将前驱节点的 next 指向 node 的后继节点node.prev.next = node.next;} else {head = node.next; // 如果是头节点，则更新头指针}if (node.next != null) { //将后继节点的 prev 指向 node 的前驱节点node.next.prev = node.prev;} else {tail = node.prev; // 如果是尾节点，则更新尾指针}}public void setHead(Node node){//使 node 成为新的头节点node.next = head;node.prev = null;//如果原头节点 head 不为空，则将其 prev 指向 nodeif (head != null) {head.prev = node;}//更新 head 为 nodehead = node;//如果 tail 为 null（链表为空），则将 tail 设置为 head，表示链表只有一个节点if (tail == null) {tail = head;}}private static class Node {int key;int value;Node prev;Node next;public Node(int key, int value) {this.key = key;this.value = value;}}
}
http://www.dtcms.com/wzjs/544327.html

相关文章：

  • 聊城有什么网站制作公司杭州科技网站
  • 什么行业适合做网站推广管理员后台管理系统
  • 网站开发费用周期请人做装修设计上什么网站
  • 天津建设网站的公司简介陕西网站制作定制
  • 企业网站管理系统的设计与实现如何做阿语垂直网站
  • 网站域名 格式一个服务器可以做两个网站
  • 做公司网站需注意什么苏州企业建站程序
  • 湘潭网站建设多少钱互联网推广公司排名
  • 学校网站源码免费惠州专业做网站
  • app官方网站吉林seo快速排名
  • 找关键词的网站揭阳网站设计公司
  • 南宁老牌网站建设公司html企业网站主页模板
  • 成都微信网站建设报价青浦网站建设
  • 手机网站设计公司只找亿企邦一般网站的跳出率
  • 东莞网站建设百度地图wordpress 在线预约插件
  • 什么网站可以做电子画册南京百度seo排名
  • 木方东莞网站建设技术支持上海闵行中心医院
  • 商水县建设局网站推广网站刷排名
  • wordpress支持建多个站点吗建站平台那个好
  • 凡科快图网站dedecms可以做双语网站
  • 网站做适配泰安网签查询系统
  • 河北省和城乡建设厅网站互联网推广和传统营销有哪些相同点
  • 网站多语言版本网站设计上海
  • 怎么做游戏门户网站工业设计在线
  • 免费 微网站沈阳网站建设小工作室
  • 滁州网站建设电话泰州网站开发公司
  • 做暧暧视频网站忻州市城乡建设管理局网站
  • 城乡建设网站证件查询系统建设网站平台的章程
  • 做网站域名的好处是什么大连图文设计有限公司
  • 邯郸市住房和城乡建设网站优化方案数学2024电子版