备战2024秋招面试题-负载均衡常见的算法

$前言：$

💞快秋招了，那么这个专栏就专门来记录一下，同时呢整理一下常见面试题
💞部分题目来自自己的面试题，部分题目来自网络整理

学习目标：

• 负载均衡常见的算法
• 算法题：组合总和

---

面试题：

负载均衡常见的算法

负载均衡指的是将用户请求分摊到不同的服务器上处理，以提高系统整体的并发处理能力以及可靠性。

大体上分为以下四种：

• 随机法
• 轮询法
• IP地址Hash法
• 最小连接数

1. 随机法

概念：随机法是最简单粗暴的负载均衡算法。所有的服务器被访问到的概率都是相同的。
适合：服务器性能相近的集群，每个服务器承载相同的负载
缺陷：可能有些机器在某一段时间内没有使用。

2. 轮询法

概念：轮询法是挨个轮询服务器处理。每个请求按时间逐一分配到不同的服务器处理。
适合：服务器性能相近的集群，其中每个服务器承载相同的负载

3. 加权轮询法

概念：在轮询法的基础上，对每个服务器配置权重，权重越高的服务器被访问的次数就越多。
适合：适合于服务器性能不等的集群，对不同性能的服务器配置不同的权重，可以使服务器的性能发挥最大性能。

一般对于性能高的服务器给予更高的权重。

4. 加权随机法

概念：在随机法的基础上，对服务器配置权重，权重越高的服务器访问的概率越大。
适合：适合于服务器性能不等的集群，不同的权重请求达到的服务器的概率不同。
缺陷：随机法的缺陷同样没有解决，因为同样有些服务器在某段时间内无法随机到。

5. IP地址Hash法

概念：通过对发送请求的客户端的 IP 地址进行求 hash 值，并对服务地址列表长度取余，选择结果对应的服务器。该方法保证了同一客户端 IP 地址会被映射到相同的后端服务器上，直到后端服务器列表发生了改变。

相同参数的请求总是发到同一台服务器处理。也就是说同个 IP 的请求会发送到同一台服务器。

6. 最小连接法

概念：有新的请求时，遍历服务器的节点列表，选择当前正在处理的请求数最小的一台服务器来连接这个请求。
优点：可以尽可能的使请求分配合理化。
缺陷：需要监控每一台服务器处理的请求连接数。有些是为每个服务器地址维护一个连接数变量来记录当前服务器连接的请求数。

---

算法题：

$题目来源：$ 39. 组合总和
$等级：中等$

👉题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
1
2
3
4
5
6

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
1
2

示例 3：

输入: candidates = [2], target = 1
输出: []
1
2

提示：

• 1 <= candidates.length <= 30
• 2 <= candidates[i] <= 40
• candidates 的所有元素 互不相同
• 1 <= target <= 40

👉代码编写

👉👉方法1

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backTracking(res, new ArrayList<>(), candidates, target, 0, 0);
        return res;
    }

    public void backTracking(List<List<Integer>> res, List<Integer> temp, int[] candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            res.add(new ArrayList<>(temp));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if (sum + candidates[i] > target) {
                return;
            }
            temp.add(candidates[i]);
            sum = sum + candidates[i];
            backTracking(res, temp, candidates, target, sum, i);
            temp.remove(temp.size() - 1);
            sum = sum - candidates[i];
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

需要明白的几个点：

• remove() 方法用于删除动态数组里的单个元素。

// 删除指定元素
arraylist.remove(Object obj)

// 删除指定索引位置的元素
arraylist.remove(int index)
1
2
3
4
5

---

完成？

• 负载均衡常见的算法

• 算法题：组合总和