双指针算法专题（2）

找往期文章包括但不限于本期文章中不懂的知识点：

个人主页：我要学编程(ಥ_ಥ)-CSDN博客

所属专栏： 优选算法专题

想要了解双指针算法的介绍，可以去看下面的博客：双指针算法的介绍 

目录

611.有效三角形的个数

LCR 179.查找总价格为目标值的两个商品

15.三数之和

18. 四数之和

 

611.有效三角形的个数

题目：

给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。

示例 1:

输入: nums = [2,2,3,4]
输出: 3
解释:有效的组合是: 
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3

示例 2:

输入: nums = [4,2,3,4]
输出: 4

提示:

  • 1 <= nums.length <= 1000
  • 0 <= nums[i] <= 1000

思路：这个题目就是想让我们在给的数组中找出可以组成三角形的个数。确定三个数是否可以组成三角形：任意两边之和大于第三边即可。

最简单的方法就是直接遍历数组，根据三角形的判断条件暴力枚举即可。

代码实现：

错误解法：暴力枚举 

class Solution {// 错误解法：暴力枚举public int triangleNumber(int[] nums) {int count = 0;// 注意这里的i,j,k的位置，i最多只能倒带倒数第三个的位置,j....for (int i = 0; i <= nums.length-3; i++) {for (int j = i+1; j <= nums.length-2; j++) {for (int k = j+1; k <= nums.length-1; k++) {if (nums[i]+nums[j] > nums[k] && nums[i]+nums[k] > nums[j] &&nums[k]+nums[j] > nums[i]) {count++;}}}}return count;}
}

由于时间复杂度过高（O(N^3)），上面的代码肯定是跑不过的。

接下来，就是想想怎么优化？

我们知道三角形的判定还有一种简单方法：两小边之和大于最大边即可。那怎么找两小边呢？一个一个的去比较吗？这个肯定不现实。其实Arrays这类中有一个静态方法可以用来对数字进行排序( sort() ) ，知道了两小边之和，就是找最大边进行判断即可。

这里我们就通过一定的条件来优化了第三层循环，减少了循环的次数。

优化解法：定位两小边 和 最大边进行比较 

class Solution {// 优化解法一：定位两小边 和 最大边进行比较public int triangleNumber(int[] nums) {Arrays.sort(nums);int count = 0;for (int i = 0; i <= nums.length-3; i++) {for (int j = i+1; j <= nums.length-2; j++) {// k此时是三个数中最大值的下标int k = j+1;while (k < nums.length) {if (nums[i]+nums[j] > nums[k]) {count++;k++;} else {// 由于数组是升序，因此后面的一定大于此时的值，因此无需判断了break;}}}}return count;}
}

既然可以定位 两小边，那么可不可以定位 最大边呢，然后找两小边进行比较呢？答案是可以的。

优化解法：固定最大边，比较另外两边

class Solution {// 优化解法二：固定最大边，比较另外两边public int triangleNumber(int[] nums) {Arrays.sort(nums);int count = 0;for (int k = nums.length-1; k >=2; k--) {// 开始寻找两小边的范围值int i = 0;int j = k-1;while (i < j) {if (nums[i]+nums[j] > nums[k]) {count += (j-i); // 满足三角形的个数j--; // i变化没意义} else {i++; // j变化没有意义}}}return count;}
}

注意：在固定最大边的优化方法中，我们只需要范围比较 nums[i] + nums[j] 与 nums[k] 的大小关系即可。没有去一个一个的遍历比较 比较 nums[i] + nums[j] 与 nums[k] 的大小关系。这就致使时间复杂度从 O(N^3) 降至 O(N^2)。

LCR 179.查找总价格为目标值的两个商品

题目：

购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。

示例 1：

输入：price = [3, 9, 12, 15], target = 18
输出：[3,15] 或者 [15,3]

示例 2：

输入：price = [8, 21, 27, 34, 52, 66], target = 61
输出：[27,34] 或者 [34,27]

提示：

  • 1 <= price.length <= 10^5
  • 1 <= price[i] <= 10^6
  • 1 <= target <= 2*10^6

思路： 很简单的思路，直接双层for循环遍历数组，去找和target的值即可。

代码实现：

错误解法：暴力枚举

class Solution {// 错误解法：暴力枚举public int[] twoSum(int[] price, int target) {int[] ret = new int[2];for (int i = 0; i < price.length; i++) {// 如果从j=0开始的话，就会有重复的，且可能会出现i==j的情况for (int j = i+1; j < price.length; j++) {if (price[i]+price[j] == target) {ret[0] = price[i];ret[1] = price[j];return ret;}}}return ret;}
}

上面的代码时间复杂度过高（O(N^2)），因此我们优化的方向就是降低时间复杂度为 O(N)。由于题目告诉我们了这个数组是有序的，并且知道了要查找的数据，因此我们可以对数据进行范围筛选。

通过上面的方法，我们会发现查找的效率直线上升了。其思路的时间复杂度为 O(N)。

正确解法：使用对撞指针，减少查询的次数，降低时间复杂度 

class Solution {public int[] twoSum(int[] price, int target) {int[] ret = new int[2];// 通过target的值来缩小范围遍历int left = 0;int right = price.length-1;while (left < right) {if (price[left]+price[right] > target) {// 大于目标值，得减小right--;} else if (price[left]+price[right] < target) {// 小于目标值。得增大left++;} else {ret[0] = price[left];ret[1] = price[right];break;}}return ret;}
}

通过上面两个题目，我们可以发现一个这样的规律：对撞指针能降低一个幂次级的时间复杂度。

例如：O(N^3) 使用对撞指针后，可以降低为 O(N^2)；O(N^2) 使用对撞指针后，可以降低为 O(N)。当然，最多也只能降低至 O(N)了，不可能直接降为O(1)。

15.三数之和

题目：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

  • 3 <= nums.length <= 3000
  • -105 <= nums[i] <= 105

思路：根据题目给出的信息来看：我们要做的事情有两步：第一，找到符合三数之和为0的数；第二，对找到的数据进行去重操作。第一步的话，首先想到的就是暴力枚举找到符合要求的数据。但是找到数据之后的去重操作是比较难的，因为三个数的虽然总体是一样的，但是其内部的顺序却不同，我们无法直接判断，因此这里我们就需要对数据进行排序操作。但问题又来了：与其选择找出数据之后排序，不如直接在原数组上面进行排序操作。可能有小伙伴会疑惑：为什么要在原数组上进行排序呢？如下图所示：

排完序之后，我们会发现重复的数据长得一模一样，因此这里我们可以使用一个天然的去重容器set来处理，最终得到的结果就是我们想要的答案。

代码实现：

错误解法：暴力枚举

class Solution {// 错误解法：暴力枚举public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>> list = new ArrayList<>();// 1、先对数组整体排序Arrays.sort(nums);// 2、再去找符合条件的数据for (int i = 0; i <= nums.length-3; i++) {List<Integer> sub_list = new ArrayList<>();for (int j = i+1; j <= nums.length-2; j++) {for (int k = j+1; k <= nums.length-1; k++) {// 这里可以优化一点点效率：>0的话，就直接跳出循环，// 大于0，再继续往后走也没用(根本不可能出现==0的情况)if (nums[i]+nums[j]+nums[k] == 0) {sub_list.add(nums[i]);sub_list.add(nums[j]);sub_list.add(nums[k]);List<Integer> integerList = new ArrayList<>(sub_list);list.add(integerList);// 每次插入数据之后，要及时清空，保证只有三个数据sub_list.clear();}}}}// 3、利用set对其去重Set<List<Integer>> set = new HashSet<>();// 遍历list将其中的元素插入set中for (int i = 0; i < list.size(); i++) {if (!set.contains(list.get(i))) {set.add(list.get(i));}}List<List<Integer>> new_list = new ArrayList<>();// 遍历set中的元素插入到new_listfor (List<Integer> x : set) {new_list.add(x);}return new_list;}
}

注意：上面代码的时间复杂度过大（三层for循环+两个遍历for循环）， 会超出时间限制。在最后一个将set中的元素插入new_list 中，可能有的小伙伴会写出下面的代码。

for (int i = 0; i < list.size(); i++) {if (set.contains(list.get(i))) {new_list.add(list.get(i));}
}

这个代码是有问题的，没有达到去重的目的。因为 list 可能中存在着多份相同的数据，但是在set 中只存在一份。因此当我们用 list 中的元素去遍历set 时，就会出现重复的元素，最终还是没有达到去重的效果。如下所示：

优化的思路有两个：1、对于查找数据时，使用对撞指针来进行优化。即通过最外层循环来固定一个数，然后再用对撞指针来找符合要求的数据。2、对去重的优化。set 去重虽然简单方便，但是两个for循环也带来了不少时间上的消耗。

1、优化查找数据：

正确解法：对撞指针优化查找数据 

class Solution {// 正确解法：使用对撞指针降低时间复杂度public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>> list = new ArrayList<>();// 1、先对数组整体排序Arrays.sort(nums);// 2、再去找符合条件的数据for (int i = 0; i <= nums.length-3; i++) {List<Integer> sub_list = new ArrayList<>();int j = i+1;int k = nums.length-1;while (j < k) {if (nums[i]+nums[j]+nums[k] == 0) {sub_list.add(nums[i]);sub_list.add(nums[j]);sub_list.add(nums[k]);List<Integer> integerList = new ArrayList<>(sub_list);list.add(integerList);sub_list.clear();// 只有一个增大，另一个减小，才可能达到相等// 这里如果不是两个同时走的话，就会超出时间限制j++; k--;} else if (nums[i]+nums[j]+nums[k] > 0) {// 得减小，k--k--;} else { // < 0// 得增加，j++j++;}}}// 3、利用set对其去重Set<List<Integer>> set = new HashSet<>();// 遍历list将其中的元素插入set中for (int i = 0; i < list.size(); i++) {if (!set.contains(list.get(i))) {set.add(list.get(i));}}List<List<Integer>> new_list = new ArrayList<>();// 遍历set中的元素插入到new_list中for (List<Integer> x : set) {new_list.add(x);}return new_list;}
}

上面的代码虽然可以通过全部的测试用例，但是时间效率非常之低。因此就要开始尝试看看能不能对去重操作进行优化。而最理想的优化就是能在找数据的同时去重。即在查找数据时，不把重复的数据算入其中，这就直接从源头上杜绝了去重的操作。那怎样才能找到不重复的数据呢？

我们会发现一个规律：当数据重复时，结果一定是相同的。即找到一组符合要求的数据之后，如果 j 对应的值 和 上一次 j 对应的值是一样的，那么就可以跳过，因为上一次 j 对应的值已经和其他值进行了结合检查。如果可以，那么就成了一次重复的数据；反之，上一次也检查过了。同理，k、i也是如此。当要注意一个数组越界问题。

class Solution {// 正确解法：对撞指针+查找去重public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>> list = new ArrayList<>();// 1、先对数组整体排序Arrays.sort(nums);// 2、再去找符合条件的数据for (int i = 0; i <= nums.length-3; i++) {// 与上一次的值相同，就不需要再进行重复的操作了while (i-1 >= 0 && i <= nums.length-3 && nums[i] == nums[i-1]) {i++;}// i对应的值一定是数组中最小的值，如果它都>0了，那肯定找不到了while (i < nums.length && nums[i] > 0) {i++;}List<Integer> sub_list = new ArrayList<>();int j = i+1;int k = nums.length-1;while (j < k) {if (nums[i]+nums[j]+nums[k] == 0) {sub_list.add(nums[i]);sub_list.add(nums[j]);sub_list.add(nums[k]);List<Integer> integerList = new ArrayList<>(sub_list);list.add(integerList);sub_list.clear();// 只有一个增大，另一个减小，才可能达到相等// 这里如果不是两个同时走的话，就会超出时间限制j++; k--;// 如果和上一次的数据相同，则跳过while (j < k && nums[j] == nums[j-1]) {j++;}while (j < k && nums[k] == nums[k+1]) {k--;}} else if (nums[i]+nums[j]+nums[k] > 0) {// 得减小，k--k--;// 数据与上一次相同的话，查找出来的还是同样的结果while (j < k && nums[k] == nums[k+1]) {k--;}} else { // < 0// 得增加，j++j++;// 数据与上一次相同的话，查找出来的还是同样的结果while (j < k && nums[j] == nums[j-1]) {j++;}}}}return list;}
}

总的来说，这一题还是比较难的。既要想要去重的方法（利用set或者查找时排序相同的元素），还要避免时间复杂度过高的情况下查找数据（使用对撞指针进行优化处理）。 

 接下来，我们再来做一道与这个极其相似的题目。

18. 四数之和

题目：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

  • 0 <= a, b, c, d < n
  • a、b、c 和 d 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

  • 1 <= nums.length <= 200
  • -109 <= nums[i] <= 109
  • -109 <= target <= 109

思路：和三数之和简直就是孪生兄弟。 同样是先排序，再去查找数据（这里只展示优化后的思路和解法，想看推导过程和暴力枚举到优化的过程，可见三数之和）。

代码实现：

错误解法：用双层对撞指针代替四层for循环+内部去重

class Solution {// 双层对撞指针会忽略一些数据public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>> list = new ArrayList<>();Arrays.sort(nums);int i = 0;int j = nums.length-1;while (i < j) {List<Integer> sub_list = new ArrayList<>();// 注意left和right的取值int left = i+1;int right = j-1;while (left < right) {// 注意：对于内层循环来说，只有left和right是可变化的，i、j都是固定的if (nums[i]+nums[j]+nums[left]+nums[right] == target) {sub_list.add(nums[i]);sub_list.add(nums[j]);sub_list.add(nums[left]);sub_list.add(nums[right]);List<Integer> integerList = new ArrayList<>(sub_list);list.add(integerList);sub_list.clear();left++;right--;while(left < right && nums[right] == nums[right+1]) {right--;}while(left < right && nums[left] == nums[left-1]) {left++;}} else if (nums[i]+nums[j]+nums[left]+nums[right] > target) {right--;while(left < right && nums[right] == nums[right+1]) {right--;}} else {left++;while(left < right && nums[left] == nums[left-1]) {left++;}}}i++;j--;while (i < j && nums[i] == nums[i-1]) {i++;}while (i < j && nums[j] == nums[j+1]) {j--;}}return list;}
}

上面代码的思路确实不错，的确可以减少不少时间的消耗，但是会漏掉一些数据。

当 nums = [-3, -1, 0, 2, 4, 5]、target = 0时，是找不到数据的。 感兴趣的小伙伴可以自己去测一测。（原本，我最先也是想到用这种方法来写，感觉效率应该会很高，但是后面经过调试发现，根本就找不出来上面的数据。）

正确解法：使用双层for循环+一层对撞指针+查找数据时去重 

class Solution {public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>> list = new ArrayList<>();// 1、排序Arrays.sort(nums);// 2、开始找数据+去重操作for (int i = 0; i <= nums.length-4;) {for (int j = i+1; j <= nums.length-3;) {List<Integer> sub_list = new ArrayList<>();int left = j+1;int right = nums.length-1;while (left < right) {if (((long)nums[i]+nums[j]+nums[left]+nums[right]) == target) {sub_list.add(nums[i]);sub_list.add(nums[j]);sub_list.add(nums[left]);sub_list.add(nums[right]);List<Integer> integerList = new ArrayList<>(sub_list);list.add(integerList);sub_list.clear();left++;right--;while(left < right && nums[right] == nums[right+1]) {right--;}while(left < right && nums[left] == nums[left-1]) {left++;}} else if ((long)nums[i]+nums[j]+nums[left]+nums[right] > target) {right--;while(left < right && nums[right] == nums[right+1]) {right--;}} else {left++;while(left < right && nums[left] == nums[left-1]) {left++;}}}j++;while (j <= nums.length-3 && nums[j] == nums[j-1]) {j++;}}i++;while (i >= 1 && i <= nums.length-4 && nums[i] == nums[i-1]) {i++;}}return list;}
}

注意：

1、

因此我们在计算四数之和时强转为了 long类型。

2、

总体来说：三数之和和四数之和还是有点难度的，不仅需要编码能力强，思路也要清新。

好啦！本期 双指针算法专题（2）的学习之旅就到此结束啦！我们下一期再一起学习吧！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/425211.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

GitLab权限及设置

GitLab权限及设置

之前很少关注这些&#xff0c;项目的权限&#xff0c;一般由专门的管理人员设置。 但自己创建的项目自己可以设置权限。下面是一些笔记。 GitLab中用户权限_gitlab 权限-CSDN博客 开发中遇到要将自己这块的代码上传到Git&#xff0c;由其他组的同事拉取后继续开发。上传代码后…
阅读更多...
【Spring Boot】SpringBoot自动装配-Import

【Spring Boot】SpringBoot自动装配-Import

目录 一、前言二、 定义三、使用说明3.1 创建项目3.1.1 导入依赖3.1.2 创建User类 3.2 测试导入Bean3.2.1 修改启动类 3.3 测试导入配置类3.3.1 创建UserConfig类3.3.2 修改启动类 3.4 测试导入ImportSelector3.4.1 创建UseImportSelector类3.4.2 修改启动类3.4.3 启动测试 3.5…
阅读更多...
LibSVM介绍及使用

LibSVM介绍及使用

介绍 LibSVM 是一个广泛使用的开源库&#xff0c;用于支持向量机&#xff08;SVM&#xff09;的实现。它由台湾大学的 Chih-Chung Chang 和 Chih-Jen Lin 开发。LibSVM 提供了一种简单易用的接口&#xff0c;支持多种 SVM 变体&#xff0c;包括分类、回归和分布估计。以下是一些…
阅读更多...
Docker-compose：管理多个容器

Docker-compose：管理多个容器

Docker-Compose 是 Docker 公司推出的一个开源工具软件&#xff0c;可以管理多个 Docker 容器组成一个应用。用户需要定义一个 YAML 格式的配置文件 docker-compose.yml&#xff0c;写好多个容器之间的调用关系。然后&#xff0c;只要一个命令&#xff0c;就能同时启动/关闭这些…
阅读更多...
大数据-132 - Flink SQL 基本介绍 与 HelloWorld案例

大数据-132 - Flink SQL 基本介绍 与 HelloWorld案例

点一下关注吧&#xff01;&#xff01;&#xff01;非常感谢&#xff01;&#xff01;持续更新&#xff01;&#xff01;&#xff01; 目前已经更新到了&#xff1a; Hadoop&#xff08;已更完&#xff09;HDFS&#xff08;已更完&#xff09;MapReduce&#xff08;已更完&am…
阅读更多...
uniapp离线（本地）打包

uniapp离线（本地）打包

安卓离线打包 注意&#xff1a;jdk建议选择1.8 下载Android Studio配置gradle仓库地址 第一步&#xff1a;先下载对应的版本&#xff0c;进行压缩包解压 第二步&#xff1a;在电脑磁盘&#xff08;D盘&#xff09;&#xff0c;创建文件夹存放压缩包并进行解压&#xff0c;并创…
阅读更多...
Netty笔记03-组件Channel

Netty笔记03-组件Channel

文章目录 Channel概述Channel 的概念Channel 的主要功能Channel 的生命周期Channel 的状态Channel 的类型channel 的主要方法 ChannelFutureCloseFuture&#x1f4a1; netty异步提升的是什么要点总结 Channel概述 Channel 的概念 在 Netty 中&#xff0c;Channel 是一个非常重…
阅读更多...
SpringDoc介绍

SpringDoc介绍

一、SpringDoc 官方文档 1.1何为SpringDoc SpringDoc是一个用来自动生成API文档的库。它是基于SpringBoot项目的&#xff0c;遵循OpenAPI3(一个组织规定的规范)规范。它是通过检查我们运行中的程序&#xff0c;推断出基于Spring配置、类结构和各种注解的API语义&#xff0c;从…
阅读更多...
网络（三）——协议是什么？？？

网络（三）——协议是什么？？？

文章目录 协议的概念结构化数据网络计算机服务端定制协议客户端代码 协议的概念 计算机之间的传输媒介是光信号和电信号。通过 “频率” 和 “强弱” 来表示 0 和 1 这样的信息。要想传递各种不同的信息&#xff0c;就需要约定好双方的数据格式。 结构化数据 我们知道TCP是面向…
阅读更多...
pgrouting实战应用

pgrouting实战应用

1&#xff09;下载地区地区数据&#xff08;下载数据是XYZM 四位数据&#xff09; 2&#xff09;下载裁剪行政区数据 3&#xff09;使用arcgis pro添加路网数据和行政区数据 4&#xff09;裁剪数据&#xff0c;仅历下行政区路网 5&#xff09;arcgis pro要素转线&#xff0…
阅读更多...
TalkSphere项目介绍

TalkSphere项目介绍

TalkSphere项目介绍 文章目录 TalkSphere项目介绍一、前言二、技术栈及开发环境三、主要功能&#xff08;一&#xff09;用户登录与注册&#xff08;二&#xff09;用户历史消息展示&#xff08;三&#xff09;在线用户实时聊天 四、结语 一、前言 在线聊天室作为一个虚拟社交…
阅读更多...
springboot3.X版本集成mybatis遇到的问题

springboot3.X版本集成mybatis遇到的问题

由于我本地springboot为3.x版本&#xff0c;如下图所示&#xff0c;最新版本 当我参照如下搜索的内容去集成mybatis的时候&#xff0c;会出现各种各样的报错 最根本的原因是搜出来的配置是参照springboot2.X版本&#xff0c;当我们使用springboot3.x版本之后&#xff0c;需要配…
阅读更多...
图论篇--代码随想录算法训练营第五十八天打卡|拓扑排序，dijkstra（朴素版），dijkstra（堆优化版）精讲

图论篇--代码随想录算法训练营第五十八天打卡|拓扑排序，dijkstra（朴素版），dijkstra（堆优化版）精讲

拓扑排序 题目链接&#xff1a;117. 软件构建 题目描述&#xff1a; 某个大型软件项目的构建系统拥有 N 个文件&#xff0c;文件编号从 0 到 N - 1&#xff0c;在这些文件中&#xff0c;某些文件依赖于其他文件的内容&#xff0c;这意味着如果文件 A 依赖于文件 B&#xff0…
阅读更多...
分布式中间件-分布式代理框架Codis和Twemproxy

分布式中间件-分布式代理框架Codis和Twemproxy

文章目录 Codis框架架构图 Twemproxy框架Codis和Twemproxy对比设计目标功能特性使用场景结论 Codis框架 Codis是一个开源的分布式内存键值存储系统&#xff0c;它基于Redis并且提供了一个分布式的解决方案来扩展单一Redis实例的能力。Codis项目由豌豆荚团队开发&#xff0c;并…
阅读更多...
【webpack4系列】webpack构建速度和体积优化策略（五）

【webpack4系列】webpack构建速度和体积优化策略（五）

文章目录 速度分析&#xff1a;使用 speed-measure-webpack-plugin体积分析&#xff1a;使用webpack-bundle-analyzer使用高版本的 webpack 和 Node.js多进程/多实例构建资源并行解析可选方案使用 HappyPack 解析资源使用 thread-loader 解析资源 多进程并行压缩代码方法一&…
阅读更多...
基于C#+Mysql实现（界面）企业的设备管理系统

基于C#+Mysql实现（界面）企业的设备管理系统

管理信息系统课程设计说明书 1 引言 企业的设备管理在企业的生产制造和管理过程之中意义比较重大&#xff0c;明确企业的设备的产权和维护成本对于企业的成本控制和财务管理之中起到了重要的作用。随着市场竞争的加剧&#xff0c;现代企业所处的市场环境发生了深刻的变革&…
阅读更多...
【Mac】系统环境配置

【Mac】系统环境配置

常用工具 Navicat PJ版本&#xff1a;this Host切换器 SwitchHosts termius 一款好用的Linux服务器连接工具&#xff1a; termius 小飞机 dddd&#xff1a;&#x1fa9c; Git mac安装git有好多种方式&#xff0c;自带的xcode或者通过Homebrew来安装&#xff0c;本文的…
阅读更多...
Java——类型转换

Java——类型转换

一、类型转换 1、介绍 类型转换分为自动类型转换和强制类型转换。 2、自动类型转换 自动类型转换是指在表达式中&#xff0c;当两种不同的数据类型组合在一起时&#xff0c;较小的数据类型会自动转换为较大的数据类型&#xff0c;这个过程是自动的&#xff0c;无需编程者手…
阅读更多...
清华大佬自曝：接到了省烟草局的offer,我就拒掉了华为！结果华为立马给我申请了特殊涨薪，总包70w是烟草的2倍，这可如何是好？

清华大佬自曝：接到了省烟草局的offer,我就拒掉了华为！结果华为立马给我申请了特殊涨薪，总包70w是烟草的2倍，这可如何是好？

《网安面试指南》http://mp.weixin.qq.com/s?__bizMzkwNjY1Mzc0Nw&mid2247484339&idx1&sn356300f169de74e7a778b04bfbbbd0ab&chksmc0e47aeff793f3f9a5f7abcfa57695e8944e52bca2de2c7a3eb1aecb3c1e6b9cb6abe509d51f&scene21#wechat_redirect 《Java代码审…
阅读更多...
C:字符串函数（续）-学习笔记

C:字符串函数（续）-学习笔记

穗 一些闲话&#xff1a; 最近玩了这款饿殍-明末千里行&#xff0c;不知大家是否有听过这款游戏&#xff0c;颇有感触&#xff01;&#xff01;&#xff01; 游戏中最让我难以忘怀的便是饿殍穗线的故事&#xff0c;生在如今时代的我之前无法理解杜甫在目睹人间悲剧时的心情&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023