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

多个织梦dedecms网站怎么做站群百度官方官网

wzjs 2025/8/4 3:01:00
多个织梦dedecms网站怎么做站群,百度官方官网,泉州市住房和乡村建设网站,临安区做网站的公司文章目录 直接刷题链接直达LRU Cache买卖股票的最佳时机系列实现一个HashMap环形链表寻找重复数缺失的第一个正数螺旋矩阵字符串相乘分发糖果 直接刷题链接直达 LRU Cache 头尾两个伪节点（避免判断） 双向链表146. LRU 缓存 买卖股票的最佳时机系列 121…

文章目录

  • 直接刷题链接直达
  • LRU Cache
  • 买卖股票的最佳时机系列
  • 实现一个HashMap
  • 环形链表
  • 寻找重复数
  • 缺失的第一个正数
  • 螺旋矩阵
  • 字符串相乘
  • 分发糖果

直接刷题链接直达

  • LRU Cache
    • 头尾两个伪节点（避免判断） + 双向链表
    • 146. LRU 缓存
  • 买卖股票的最佳时机系列
    • 121. 买卖股票的最佳时机
  • 实现一个HashMap
    • 要求：1. 定义内部存储结构； 2.实现 insert(key, value) 和 remove(key)；3.不能使用任何Java集合框架。
    • 706. 设计哈希映射
  • 求给定区间内子区间的最大值（区间内最小值*区间元素相加）
    • 要求时间复杂度O(n)
    • 原题
  • 斐波那契数列的尾递归实现
    • 面试官原意是斐波那契的递归实现如何优化
    • 尾递归就是把当前的运算结果（或路径）放在参数里传给下层函数
    • 递归与尾递归总结
  • 1到10000有多少个数字7
    • 答案 ：4000
    • 腾讯面试题-0到9999这1万个数中有多少个数字7
  • 给定精度（如小数点后10位），写一个函数求根号2的具体值
    • 牛顿法，详见 如何通俗易懂地讲解牛顿迭代法求开方？数值分析？
    • 69. x 的平方根
  • 给定一个乱序数组[0,100]，替换其中一个数，找出这个被替换的数
    • 类似 142. 环形链表 II 思路，重复数字会形成环，双指针寻找
    • 287. 寻找重复数
  • 缺失的第一个正数
    • 41. 缺失的第一个正数
  • 顺时针打印矩阵（星环）
    • 54. 螺旋矩阵
  • 实现一个int转中文表示的函数，同时设计测试用例
    • 定界数据范围 + 梳理演变规则（以“万”为节，化繁为简，以及“零”如何处理）
    • 数字(int型范围内正整数)和中文的相互转换
  • 100盏灯问题
    • 面试题—100盏灯问题
  • 给定一个数组，一个闭区间[n,m]，给出该数组中所有最大值在闭区间中的连续子数组数目
    • 要求时间复杂度O(n)
    • 如 [2,1,4,3]，[2,3]，有[2],[2,1],[3]，返回3
  • 字符串相乘
    • 43. 字符串相乘
  • 用Java实现一个String转Map（Map<String,Object>）的函数，不能使用String的split和第三方库
  • 整数中1出现的次数（从1到n中1出现的次数）
    • 233. 数字 1 的个数
  • 单词接龙
    • 广度优先 --> 队列 + 暴力搜索（遍历过的单词删除），视频讲解见 花花酱 LeetCode 127. Word Ladder - 刷题找工作 EP71
    • 127. 单词接龙
  • 分数到小数
    • 将除法过程代码化
    • 166. 分数到小数
  • 只出现一次的数字
    • 136. 只出现一次的数字
  • 分糖果
    • 从左至右扫一遍，再从右至左扫一遍，取两遍中的最大值
    • 135. 分发糖果
  • 实现一个命令行逆波兰计算器
    • CommandLineRPN
  • Largest M-aligned Subset
    • Microsoft | OA 2020 | Largest M-aligned Subset

LRU Cache

请你设计并实现一个满足 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) 的平均时间复杂度运行。

class LRUCache {private final int capacity;// 双向链表 put 操作 会把数据放表尾-》最近最久未使用在表头（remove去掉表头）private final LinkedHashMap<Integer, Integer> data;public LRUCache(int capacity) {this.capacity = capacity;this.data = new LinkedHashMap<>(capacity);}public int get(int key) {// 这个key存在 =》 删除，放表尾if (data.containsKey(key)) {Integer value = data.remove(key);data.put(key, value);return value;}return -1;}public void put(int key, int value) {if (data.containsKey(key)) {data.remove(key);data.put(key, value);return;}if (data.size() == capacity) {// 删除表头元素data.remove(data.keySet().iterator().next());}data.put(key, value);}
}

补充：

class LRUCache {private static class Node {int key, value;Node prev, next;Node(int k, int v) {key = k;value = v;}}private final int capacity;private final Node dummy = new Node(0, 0); // 哨兵节点private final Map<Integer, Node> keyToNode = new HashMap<>();public LRUCache(int capacity) {this.capacity = capacity;dummy.prev = dummy;dummy.next = dummy;}public int get(int key) {Node node = getNode(key); // getNode 会把对应节点移到链表头部return node != null ? node.value : -1;}public void put(int key, int value) {Node node = getNode(key);if (node != null) { // 有这本书node.value = value; // 更新 valuereturn;}node = new Node(key, value); // 新书keyToNode.put(key, node);pushFront(node); // 放在最上面if (keyToNode.size() > capacity) { // 书太多了Node backNode = dummy.prev;keyToNode.remove(backNode.key);remove(backNode); // 去掉最后一本书}}// 获取 key 对应的节点，同时把该节点移到链表头部private Node getNode(int key) {if (!keyToNode.containsKey(key)) { // 没有这本书return null;}Node node = keyToNode.get(key); // 有这本书remove(node); // 把这本书抽出来pushFront(node); // 放在最上面return node;}// 删除一个节点（抽出一本书）private void remove(Node x) {x.prev.next = x.next;x.next.prev = x.prev;}// 在链表头添加一个节点（把一本书放在最上面）private void pushFront(Node x) {x.prev = dummy;x.next = dummy.next;x.prev.next = x;x.next.prev = x;}
}

买卖股票的最佳时机系列

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {public int maxProfit(int[] prices) {int mp = Integer.MAX_VALUE;int max = Integer.MIN_VALUE;for (int p:prices) {if (p < mp) {mp = p;}max = Math.max(max, p - mp);}return max;}
}

实现一个HashMap

public class MyHashMap {int capacity = 16;class Node {int key;int value;Node next;public Node() {this.next = null;}public Node(int key, int value) {this.key = key;this.value = value;this.next = null;}}Node[] bucket;public MyHashMap() {this.bucket = new Node[capacity];}public void put(int key, int value) {int i = key % capacity;if (bucket[i] == null) {bucket[i] = new Node(key, value);return;}Node temp = bucket[i];if (temp.key == key) {temp.value = value;return;}while (temp.next != null) {if (temp.next.key == key) {temp.next.value = value; // fix herereturn;}temp = temp.next;}temp.next = new Node(key, value); // insert at end}public int get(int key) {int i = key % capacity;Node temp = bucket[i];while (temp != null) {if (temp.key == key) {return temp.value;}temp = temp.next;}return -1; // not found}public void remove(int key) {int i = key % capacity;Node temp = bucket[i];if (temp == null) return;if (temp.key == key) {bucket[i] = temp.next;return;}while (temp.next != null) {if (temp.next.key == key) {temp.next = temp.next.next;return;}temp = temp.next;}}
}

环形链表

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

思路：

  • 快慢指针 判断是否有环。
  • 有环，快指针=第一个节点，然后两个指针向下遍历，相遇的点就是开始入环的第一个节点。
public class Solution {public ListNode detectCycle(ListNode head) {if (head == null || head.next == null) return null;ListNode fast = head;ListNode slow = head;// 快慢指针：判断是否有环while (fast != null && fast.next != null) {fast = fast.next.next;slow = slow.next;if (fast == slow) {break;}}// 没有环if (fast == null || fast.next == null) {return null;}// 有环：重新让 fast 从头走，和 slow 一起一步一步走，相遇点就是环的入口fast = head;while (fast != slow) {fast = fast.next;slow = slow.next;}return slow;}
}

寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

将数组视为链表，nums[i] 表示“指针”，指向 nums[nums[i]]。

💡 思路：
把 nums 看成链表，数组下标是节点编号，值是指针指向的下一个节点；

因为有重复值，所以一定有“环”；

问题转化为：找这个链表的“环入口”，这就是“重复的数”。

public class Solution {public int findDuplicate(int[] nums) {// 初始化快慢指针int slow = nums[0];int fast = nums[0];// 第一步：快慢指针找相遇点（在环中）do {slow = nums[slow];fast = nums[nums[fast]];} while (slow != fast);// 第二步：找环的入口（即重复的数字）fast = nums[0];while (fast != slow) {fast = nums[fast];slow = nums[slow];}return slow; // or fast}
}

缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

思想：把每个数字放到它“该去的位置”，然后再检查哪个位置缺少那个数字。

class Solution {public int firstMissingPositive(int[] nums) {// 把每个数字放到它“该去的位置”，然后再检查哪个位置缺少那个数字。int i = 0;while (i < nums.length) {if (nums[i] != i+1 && nums[i] > 0 && nums[i] <= nums.length && nums[nums[i] - 1] != nums[i]) {int temp = nums[nums[i]-1];nums[nums[i]-1] = nums[i];nums[i] = temp; }else {i++;}}for (int k = 0; k < nums.length; k++) {if (nums[k] != k + 1) {return k+1;}}return nums.length + 1;}
}

螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

class Solution {public List<Integer> spiralOrder(int[][] matrix) {List<Integer> ans = new ArrayList<>();int m = matrix.length;int n = matrix[0].length;// 边界int l = 0, r = n - 1, t = 0, b = m - 1;while (l <= r && t <= m) {// 左 到 右for (int i = l; i <= r; i++) {ans.add(matrix[t][i]);}// 边界判断if (++t > b) break;// 上 到 下for (int i = t; i <= b; i++) {ans.add(matrix[i][r]);}if (--r < l) break;// 右 到 左for (int i = r; i >= l; i--) {ans.add(matrix[b][i]);}if (--b < t) break;// 从 下 到 上for (int i = b; i >= t;i--) {ans.add(matrix[i][l]);}if (++l > r) break;}return ans;}}

字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

注意：不能使用任何内置的 BigInteger 库或直接将输入转换为整数。

class Solution {public String multiply(String num1, String num2) {if ("0".equals(num1) || "0".equals(num2)) return "0";int m = num1.length();int n = num2.length();int[] res = new int[m + n]; // 最多 m+n 位for (int i = m - 1; i >= 0; i--) {int a = num1.charAt(i) - '0';for (int j = n-1; j >= 0; j--) {int b = num2.charAt(j) - '0';int sum = res[i+j+1] + a*b;res[i+j+1] = sum % 10;res[i+j] += sum/10; // +=}}// 转换成字符串，去掉前导0StringBuilder sb = new StringBuilder();for (int num : res) {if (sb.length() == 0 && num == 0) continue;sb.append(num);}return sb.toString();}
}

分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

  • 每个孩子至少分配到 1 个糖果。
  • 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

class Solution {public int candy(int[] ratings) {int n = ratings.length;int[] candys = new int[n];// 每个孩子至少分配到 1 个糖果Arrays.fill(candys, 1);// 从 左 到 右 遍历：相邻两个孩子评分更高的孩子会获得更多的糖果for (int i = 1; i < n; i++) {if (ratings[i] > ratings[i-1]) {candys[i] = candys[i-1]+1;}}// 从 右 到 左 遍历：相邻两个孩子评分更高的孩子会获得更多的糖果for (int i = n-2; i >= 0; i--) {if (ratings[i] > ratings[i+1]) {candys[i] = Math.max(candys[i], candys[i+1]+1);}}int sum = 0;for (int i = 0; i < n; i++) {sum += candys[i];}return sum;}
}
http://www.dtcms.com/wzjs/210494.html

相关文章：

  • 河北做it的网站加快实施创新驱动发展战略
  • 怎么做网络推广品牌哪家强北京网站seo公司
  • 网站中flash怎么做今日头条新闻
  • php网站的客服窗口怎么做的查关键词
  • 河东苏州网站建设刷关键词排名seo软件
  • 网站设计与制作培训学校选择宁波seo优化公司
  • 模板式网站建设怎样建立个人网站
  • 深圳政府网站建设开平网站设计
  • 做JAVA基础编程题什么网站好长春百度推广排名优化
  • 有没有一起做网站的百度权重什么意思
  • 网站建设的公司业务seo公司多少钱
  • 金山石化网站建设seo最好的工具
  • 情公司做的网站怎么在网上销售
  • 网站建设H5 源码求个网站
  • 专业的购物网站定制成都百度推广公司电话
  • 廊坊做网站优化的公司百度快照优化
  • 闵行营销型网站建设公司it培训机构靠谱吗
  • 网站建设措施无限制搜索引擎排名
  • 网站首页快照怎么做网络推广计划方案
  • 网站做优化好还是做推广好网站正能量免费推广软件
  • 上海设计院排名独立站优化
  • prizm viewer wordpressseo优化培训公司
  • 上海seo优化公司 kinglinkseo企业站收录
  • 给政府做网站的公司网络营销与管理专业是干什么的
  • 沈阳做网站企业大数据营销
  • 广东高端网站建设vi设计
  • 哪里有网站制作技术seo是对网站进行什么优化
  • 查网站的关键词排名吗网络销售入门基本知识
  • 乐清案例上传网站爱站网关键词怎么挖掘
  • 保定网站建设价格互联网广告代理