【互联网面试】练习题

【互联网面试】练习题
手撕代码

 相似字符串交换

给定两个字符串A,B，如果字符串A可以通过交换其中两个字符的顺序，而合B相等，则两个字符串相似
要确定两个字符串A和B是否相似，你可以按照以下步骤进行比较：

确保两个字符串的长度相等，因为如果它们的长度不同，它们绝对不会相似。

遍历字符串A和B的每个字符，分别记录它们的不匹配字符的索引。如果不匹配字符的数量超过2个，那么这两个字符串不相似。

如果不匹配字符的数量为0，那么这两个字符串已经相同，它们也可以被认为是相似的。

如果不匹配字符的数量为2，那么你需要检查这两个字符是否可以通过交换它们的位置使得字符串A等于字符串B。如果可以，那么这两个字符串是相似的。

以下是一个Python示例代码，用于判断两个字符串是否相似：
```
def are_strings_similar(A, B):
    if len(A) != len(B):
        return False

    mismatch_indices = []
    for i in range(len(A)):
        if A[i] != B[i]:
            mismatch_indices.append(i)

    if len(mismatch_indices) == 0:
        return True
    elif len(mismatch_indices) == 2:
        i, j = mismatch_indices
        return A[i] == B[j] and A[j] == B[i]
    else:
        return False

# 示例用法
A = "abcde"
B = "badec"
if are_strings_similar(A, B):
    print("A 和 B 相似")
else:
    print("A 和 B 不相似")

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
```
排序

 冒泡排序

冒泡排序（Bubble Sort）：

冒泡排序是一种基本的排序算法，其思想是通过反复交换相邻的元素，将较大的元素逐渐向数组的尾部移动，较小的元素逐渐向数组的头部移动，直到整个数组有序。

工作原理：

从数组的第一个元素开始，比较相邻的两个元素。
如果它们的顺序错误（按升序排序），则交换它们的位置。
继续比较和交换相邻的元素，直到遍历整个数组。
重复上述步骤，每次遍历将最大的元素冒泡到数组的最后一个位置，然后排除掉最后一个元素，再次进行遍历。
冒泡排序的时间复杂度是O(n^2)，其中n是数组的元素个数。它是一种比较简单但效率较低的排序算法，适用于小型数据集。
```
#include 

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, n);

    std::cout << "冒泡排序结果: ";
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }

    return 0;
}

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
26
27
28
29
```
```
def bubble_sort(arr):
    n = len(arr)

    for i in range(n):
        # 最后i个元素已经排序好，所以不需要再比较
        for j in range(0, n - i - 1):
            # 如果当前元素比下一个元素大，则交换它们
            if arr[j] > arr[j + 1]:
             #   arr[j], arr[j + 1] = arr[j + 1], arr[j]
             s=arr[j]
             arr[j]  = arr[j + 1]
             arr[j + 1]= s
# 测试冒泡排序
if __name__ == "__main__":
    arr = [64, 34, 25, 12, 22, 11, 90]

    bubble_sort(arr)

    print("排序后的数组:")
    for i in arr:
        print(i, end=" ")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
插入排序

插入排序（Insertion Sort）：

插入排序是一种稳定的排序算法，其思想是将数组划分为已排序和未排序两部分，逐个将未排序部分的元素插入到已排序部分的合适位置。

工作原理：

从第二个元素开始，将它插入到已排序部分的正确位置，使得已排序部分仍然有序。
持续重复上述步骤，逐个将未排序部分的元素插入到已排序部分，直到所有元素都被排序。
插入排序的时间复杂度也是O(n^2)，但在某些情况下，它比冒泡排序效率稍高，特别是当数据接近有序时。插入排序在小型数据集或基本有序的数据集上表现良好。
```
#include 

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;

        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }

        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);

    std::cout << "插入排序结果: ";
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }

    return 0;
}

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
26
27
28
29
30
```
```
def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1

        # 将arr[i]插入到已排序的部分
        while j >= 0 and key < arr[j]:
            arr[j+1] = arr[j]
            j -= 1
        arr[j + 1] = key


# 测试插入排序
if __name__ == "__main__":
    arr = [64, 34, 25, 12, 22, 11, 90]

    insertion_sort(arr)

    print("排序后的数组:")
    for i in arr:
        print(i, end=" ")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
```
快速排序

快速排序（Quick Sort）是一种高效的、基于分治法的排序算法。它的基本思想是选取一个基准元素，将数组分割为两个子数组，一个子数组中的元素都小于基准，另一个子数组中的元素都大于基准，然后递归地对这两个子数组进行排序。以下是快速排序的原理和相应的C++代码示例：

快速排序的原理：

选择一个基准元素（通常是数组中的一个元素）。
将数组分为两个子数组，一个包含小于基准的元素，另一个包含大于基准的元素。这个过程称为分区（partitioning）。
对这两个子数组递归地应用快速排序算法。
合并已排序的子数组，即将基准元素放在中间，小于基准的元素在左边，大于基准的元素在右边，完成排序。
```
#include 
#include 

// 分区函数，将数组分成两部分，返回分区点的索引
int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }

    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

// 快速排序函数
void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int partitionIndex = partition(arr, low, high);
        quickSort(arr, low, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, high);
    }
}

int main() {
    std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
    int n = arr.size();

    quickSort(arr, 0, n - 1);

    std::cout << "快速排序结果: ";
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }

    return 0;
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
```
二叉树

 层次遍历二叉树

层次遍历（Level Order Traversal）二叉树是一种广度优先的遍历方式，它从树的根节点开始，逐层地访问树中的节点，从左到右遍历每一层。层次遍历可以使用队列数据结构来实现。以下是一个Python示例代码，用于层次遍历二叉树：
```
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def level_order_traversal(root):
    if root is None:
        return []

    result = []
    queue = [root]

    while queue:
        current_node = queue.pop(0)  # 弹出队列的第一个节点
        result.append(current_node.value)

        if current_node.left:
            queue.append(current_node.left)
        if current_node.right:
            queue.append(current_node.right)

    return result

# 示例用法
# 创建一个二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)

# 执行层次遍历
result = level_order_traversal(root)
print("层次遍历结果:", result)

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
26
27
28
29
30
31
32
33
34
35
36
37
38
```
计算机相关

 写一个程序判断计算机是大端存储还是小端存储

判断计算机是大端存储还是小端存储可以通过检查计算机对整数类型数据的字节序的方式来实现。以下是一个C++程序，用于判断计算机的字节序：
```
#include 

int main() {
    unsigned int num = 1;
    // 将整数1存储到字节数组中
    unsigned char *byteArray = reinterpret_cast<unsigned char*>(&num);

    if (byteArray[0] == 1) {
        std::cout << "这台计算机是小端存储 (Little Endian)" << std::endl;
    } else {
        std::cout << "这台计算机是大端存储 (Big Endian)" << std::endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
这个程序的核心是将整数1存储到字节数组中，然后检查字节数组的第一个字节（最低有效字节）。如果第一个字节为1，则表示计算机是小端存储（Little Endian），因为最低有效字节存储在最低地址。如果第一个字节不是1，则表示计算机是大端存储（Big Endian），因为最高有效字节存储在最低地址。

请注意，这个方法对于大多数现代计算机是有效的，但并不适用于所有情况，因为某些特殊体系结构可能具有不同的字节序。

简答题

 进程和线程的差别

进程（Process）和线程（Thread）是计算机科学中的两个重要概念，用于管理程序的并发执行。它们之间有一些重要的区别：

定义：

进程：进程是操作系统分配资源和管理任务的基本单位。每个进程都有独立的内存空间，文件句柄以及系统资源。
线程：线程是进程内的执行单元，一个进程可以包含多个线程，它们共享进程的内存空间和资源。
独立性：

进程：进程是相互独立的，它们之间不会共享内存空间，一个进程的崩溃通常不会影响其他进程。
线程：线程是进程内的执行单元，它们共享进程的内存空间，因此一个线程的问题可能会影响整个进程。
资源开销：

进程：创建和销毁进程通常需要较大的资源开销，包括内存和处理器时间。
线程：创建和销毁线程通常比进程轻量，因为它们共享进程的资源。
通信和同步：

进程：进程之间的通信较为复杂，通常需要使用进程间通信（IPC）机制，如管道、消息队列等。
线程：线程之间的通信和同步相对容易，因为它们可以直接访问共享的内存，但也需要小心处理同步问题，以避免竞态条件和死锁。

判断点在三角形内

要判断一个点是否在一个三角形内，你可以使用以下方法：

计算三角形的面积：首先，计算给定三角形的面积。你可以使用三个顶点的坐标和行列式计算公式来找到面积。

计算点到三个三角形顶点的距离：使用点到三个三角形顶点的距离公式，分别计算点到三个顶点的距离。

判断点是否在三角形内：如果点在三角形内，那么点到三个顶点的距离之和应该等于三角形的面积。具体判断条件是：点到三个顶点的距离之和等于三角形的面积，即 distance(point, vertex1) + distance(point, vertex2) + distance(point, vertex3) == triangle_area。

如果上述条件成立，那么点在三角形内。否则，点不在三角形内。

以下是一个示例的C++代码，用于判断一个点是否在一个三角形内：
```
#include 
#include 

// 计算两点之间的距离
double distance(const std::pair<double, double>& p1, const std::pair<double, double>& p2) {
    double dx = p1.first - p2.first;
    double dy = p1.second - p2.second;
    return sqrt(dx * dx + dy * dy);
}

// 计算三角形的面积
double calculateTriangleArea(const std::pair<double, double>& vertex1, const std::pair<double, double>& vertex2, const std::pair<double, double>& vertex3) {
    return 0.5 * fabs(vertex1.first * (vertex2.second - vertex3.second) + vertex2.first * (vertex3.second - vertex1.second) + vertex3.first * (vertex1.second - vertex2.second));
}

// 判断点是否在三角形内
bool isPointInTriangle(const std::pair<double, double>& point, const std::pair<double, double>& vertex1, const std::pair<double, double>& vertex2, const std::pair<double, double>& vertex3) {
    double triangle_area = calculateTriangleArea(vertex1, vertex2, vertex3);
    double total_distance = distance(point, vertex1) + distance(point, vertex2) + distance(point, vertex3);
    return std::abs(total_distance - triangle_area) < 1e-6; // 使用误差容限进行比较
}

int main() {
    std::pair<double, double> point(2.0, 2.0);
    std::pair<double, double> vertex1(0.0, 0.0);
    std::pair<double, double> vertex2(4.0, 0.0);
    std::pair<double, double> vertex3(0.0, 4.0);

    if (isPointInTriangle(point, vertex1, vertex2, vertex3)) {
        std::cout << "点在三角形内" << std::endl;
    } else {
        std::cout << "点不在三角形内" << std::endl;
    }

    return 0;
}

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
26
27
28
29
30
31
32
33
34
35
36
37
```
用python实现：
```
import math

# 计算两点之间的距离
def distance(p1, p2):
    dx = p1[0] - p2[0]
    dy = p1[1] - p2[1]
    return math.sqrt(dx * dx + dy * dy)

# 计算三角形的面积
def calculate_triangle_area(vertex1, vertex2, vertex3):
    return 0.5 * abs(vertex1[0] * (vertex2[1] - vertex3[1]) + vertex2[0] * (vertex3[1] - vertex1[1]) + vertex3[0] * (vertex1[1] - vertex2[1]))

# 判断点是否在三角形内
def is_point_in_triangle(point, vertex1, vertex2, vertex3):
    triangle_area = calculate_triangle_area(vertex1, vertex2, vertex3)
    total_distance = distance(point, vertex1) + distance(point, vertex2) + distance(point, vertex3)
    return abs(total_distance - triangle_area) < 1e-6  # 使用误差容限进行比较

point = (2.0, 2.0)
vertex1 = (0.0, 0.0)
vertex2 = (4.0, 0.0)
vertex3 = (0.0, 4.0)

if is_point_in_triangle(point, vertex1, vertex2, vertex3):
    print("点在三角形内")
else:
    print("点不在三角形内")

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
26
27
28
```
绳子分成三段，求最大乘积

要使得绳子分成3段，且这三段长度的乘积最大，可以使用数学方法来确定每段的长度。这是一个优化问题，可以使用微积分来解决。具体步骤如下：

假设绳子的总长度为L，我们要将其分成3段，即 x、y 和 z。那么我们需要找到一个优化目标，即最大化 x * y * z。

为了找到最大的 x * y * z，我们可以使用微积分，将其转化为一个最大化问题。首先，将绳子分成3段，可以表示为 L = x + y + z。

我们可以使用拉格朗日乘数法来解决这个问题。我们要最大化函数 F(x, y, z, λ) = x * y * z + λ * (L - x - y - z)，其中 λ 是拉格朗日乘数。

对 F 求偏导数，分别对 x、y、z 和 λ 求偏导数，并令它们等于零，可以得到最大化 x * y * z 的条件。这将导致 x = y = z = L / 3。

所以，为了使得三段长度的乘积最大，每段长度应该是 L / 3。

这样，当绳子的总长度为L时，将绳子均匀地分成三段，每段的长度都是 L / 3，将会使得乘积 x * y * z 最大。

下面是一个Python示例代码，用于计算绳子分成三段时的最大乘积：
```
def max_product_of_three_segments(L):
    if L <= 0:
        return 0
    return (L / 3) ** 3

# 示例用法
rope_length = 12  # 绳子的总长度
max_product = max_product_of_three_segments(rope_length)
print("最大乘积:", max_product)

1
2
3
4
5
6
7
8
9
10
```
两个鸡蛋判断最少从哪层楼扔下来会碎，怎么弄比较好

在经典的鸡蛋问题中，有两个鸡蛋和一个高楼，你需要确定从哪一层楼扔鸡蛋，以便在最少的尝试次数内确定鸡蛋会碎的楼层。这是一个著名的计算机科学问题，通常称为 “二分法查找鸡蛋掉落楼层” 问题。以下是一种最小化尝试次数的策略，通常称为 “二分法”：

首先，选择一个初始的楼层高度，比如第一层，然后扔第一个鸡蛋。

如果第一个鸡蛋碎了，你需要逐层地测试从第一层到碎掉的楼层，找出鸡蛋碎的楼层，这需要最多的尝试次数是当前楼层的高度。

如果第一个鸡蛋没有碎，那么你可以继续往上增加楼层高度，然后再次扔第一个鸡蛋。

重复步骤 2 和 3，逐渐增加楼层高度，直到第一个鸡蛋碎了。

一旦第一个鸡蛋碎了，你可以使用第二个鸡蛋来进行线性搜索，从上一次没有碎的楼层开始，逐层测试，找出鸡蛋碎的楼层。

这种策略最多需要的尝试次数是楼层的高度和线性搜索的次数之和，通常能够在最小的尝试次数内确定鸡蛋会碎的楼层。

这是一种经典的策略，通常被称为二分法查找鸡蛋掉落楼层问题中的 “二分法”。此策略可以有效地降低尝试次数，但仍然取决于楼层的高度和鸡蛋的数量。

设计模式了解哪些，MVC解决什么问题

设计模式是一种在软件开发中广泛使用的可重用解决方案，用于解决常见的设计问题。其中一些常见的设计模式包括：

单例模式（Singleton）：保证一个类只有一个实例，并提供一个全局访问点。

工厂模式（Factory）：用于创建对象，但隐藏了对象的创建逻辑。

抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。

建造者模式（Builder）：用于分步骤地构建一个复杂对象。

原型模式（Prototype）：通过复制现有对象来创建新对象，而不是使用构造函数。

适配器模式（Adapter）：允许接口不兼容的类可以一起工作。

装饰器模式（Decorator）：动态地为对象添加新功能，而无需修改其代码。

代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。

观察者模式（Observer）：定义对象之间的一对多依赖，当一个对象状态发生变化时，所有依赖它的对象都会得到通知并自动更新。

策略模式（Strategy）：定义一系列算法，将它们封装起来，并使它们可以互相替换。

命令模式（Command）：将请求封装成一个对象，从而允许你参数化客户端与队列请求，将请求或操作的发出者和执行者解耦。

状态模式（State）：允许对象在其内部状态改变时改变它的行为。

模板方法模式（Template Method）：定义算法的骨架，允许子类实现算法的具体步骤。

责任链模式（Chain of Responsibility）：允许你将请求沿处理链传递，直到有一个处理器处理它。

迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

MVC（Model-View-Controller）是一种软件设计模式，用于解决应用程序的分层问题，尤其是在构建用户界面时。MVC模式将应用程序分为三个关键部分：

模型（Model）：模型表示应用程序的数据和业务逻辑。它独立于用户界面和控制器，负责管理数据的状态和提供对数据的访问和更新。

视图（View）：视图是用户界面的部分，负责将模型的数据呈现给用户，并接收用户输入。视图通常不包含业务逻辑，只负责展示数据。

控制器（Controller）：控制器负责处理用户输入，协调模型和视图之间的交互。它接收来自用户的操作，更新模型的数据，并将更新后的数据反映在视图上。

MVC模式的主要目标是将应用程序的不同方面分开，使其更易于维护和扩展。它提供了一种清晰的分层方法，有助于组织代码，并使不同部分之间的交互更加明确和可控。MVC模式也有助于实现用户界面和应用逻辑之间的松耦合，使得开发团队可以更轻松地协作和管理代码。

计算机存储类型（寄存器，内存，磁盘）

一个程序中那些地方需要访问寄存器，内存，磁盘
计算机存储类型包括寄存器（Registers）、内存（RAM，Random Access Memory）、磁盘（硬盘或固态硬盘）。程序在不同的存储类型中进行数据访问，以实现不同的目标和优化性能。以下是程序中通常需要访问这些存储类型的一些常见情况：

寄存器（Registers）：

寄存器变量：编译器通常会使用寄存器来存储程序中频繁使用的变量，以加快访问速度。程序员也可以使用寄存器变量指示编译器将某个变量存储在寄存器中。
汇编语言编程：在汇编语言编程中，程序员可以直接访问和操作寄存器，以执行底层的操作。
内存（RAM）：

变量和数据结构：大多数程序中的变量和数据结构存储在内存中，以便进行读取和写入操作。
堆和栈：内存用于存储程序的堆和栈，用于动态分配内存和存储函数调用的局部变量。
磁盘（硬盘或固态硬盘）：

文件操作：磁盘存储用于保存文件和数据，程序可以读取和写入文件。
持久性数据：数据库和应用程序的配置文件通常存储在磁盘上，以实现数据的持久性和长期存储。
虚拟内存：操作系统可以使用磁盘作为虚拟内存的扩展，以支持大型程序和数据集。
程序通常需要在这三种存储类型之间进行数据传输和交换，以执行各种操作。例如，程序将数据从磁盘加载到内存中，对其进行处理，然后将结果存回磁盘。或者程序将数据从内存加载到寄存器中以进行快速计算。

优化程序的性能通常涉及到有效地管理和访问这些不同存储类型中的数据，以减少延迟和提高效率。这包括合理使用寄存器、内存和磁盘，以及使用适当的数据结构和算法来减少数据的访问次数和复制。

手机CPU和电脑CPU区别

手机 CPU（Central Processing Unit，中央处理单元）和计算机 CPU 在原理上是相似的，都是用于执行计算和控制计算机系统的核心组件。然而，它们在一些关键方面存在差异，主要体现在以下几个方面：

性能：计算机 CPU 通常比手机 CPU 更强大，因为计算机通常需要处理更复杂的任务和更大的数据集。计算机 CPU 配备了更多的核心、更大的高速缓存以及更高的时钟频率，以应对复杂的计算需求。

功耗和散热：手机 CPU 需要在相对较小和紧凑的空间内工作，因此必须在功耗和散热方面更加高效。手机 CPU 通常采用低功耗设计，以延长电池寿命，并且需要更好的散热解决方案，以避免过热。

集成：手机 CPU 通常集成了其他组件，如图形处理单元（GPU）、内存控制器、信号处理器等，以减小手机尺寸并提供更好的性能。计算机 CPU 更多是独立的处理器，其他组件通常是单独的芯片或插槽。

架构：计算机 CPU 使用的是x86或x86-64架构，而手机 CPU 使用的是ARM架构。这意味着软件必须适用于不同的指令集架构，或者通过模拟器来运行。

能效：手机 CPU 更注重能效，以延长电池寿命。计算机 CPU 更注重性能，因为电源通常是可靠的电源插座。

操作系统和软件：手机和计算机通常运行不同的操作系统，手机通常运行Android或iOS，而计算机运行Windows、macOS或Linux。这些不同的操作系统和应用程序生态系统需要不同的软件支持。

总的来说，手机 CPU 和计算机 CPU 在性能、功耗、架构、集成和应用场景上存在显著差异，它们各自针对不同的需求和使用情况进行了优化。手机 CPU 更适用于便携式设备，而计算机 CPU 更适用于台式机和笔记本电脑等大型计算设备。

tcp三次握手，为什么不是两次或者四次

TCP的三次握手是为了建立一个可靠的双向通信连接，其中两个端点（通常是客户端和服务器）需要达成一致，以确保数据的可靠传输。为什么不是两次或四次呢？让我解释一下：

为什么不是两次？
如果只进行两次握手，存在一些潜在问题，其中一个主要问题是可能会导致"半开"连接。在两次握手情况下，客户端发送连接请求，服务器回复确认，然后连接就建立了。但如果客户端没有收到服务器的确认，它不知道连接是否建立成功，而服务器也不知道客户端是否成功建立连接。这种情况下，服务器可能会浪费资源等待客户端的数据，而客户端也可能会认为连接已经建立，但实际上并没有。三次握手可以解决这个问题，因为它确保了双方都知道连接已经成功建立。

为什么不是四次？
四次握手是不必要的，因为TCP连接的目标是建立连接和终止连接。在连接建立后，数据可以双向传输，而在连接终止后，数据传输应该停止。在三次握手后，连接建立并且双方都知道连接已经建立。当需要终止连接时，TCP使用四次握手来确保双方都知道连接已经关闭，避免数据丢失或重新传输。

因此，三次握手是TCP协议设计的一种最佳方式，它确保了连接的可靠性和一致性，既避免了"半开"连接的问题，又能够正确地终止连接。四次握手则用于连接的正常终止。

TCP（传输控制协议，Transmission Control Protocol）是一种在计算机网络中广泛使用的协议，用于在不可靠的网络上建立可靠的数据传输连接。TCP确保数据的可靠性、完整性和有序性，它是互联网协议套件（TCP/IP）的一部分，用于在不同设备之间进行数据通信。

TCP的握手（handshake）是指在建立TCP连接时进行的初始化步骤，通常称为"三次握手"。这个过程的主要目的是确保通信双方都准备好进行数据传输，以避免数据丢失或混乱。下面是TCP三次握手的过程：

第一次握手（SYN）：
客户端向服务器发送一个SYN（同步）数据包，表示它想要建立连接，并选择一个初始的序列号（sequence number）。

第二次握手（SYN-ACK）：
服务器接收到客户端的SYN后，回复一个SYN-ACK数据包，表示它接受了连接请求，并选择自己的初始序列号。同时，服务器也确认了客户端的初始序列号。

第三次握手（ACK）：
客户端接收到服务器的SYN-ACK后，发送一个ACK（确认）数据包，确认了连接建立。此时，双方都准备好在连接上进行数据传输。

完成了这个三次握手过程后，TCP连接就建立起来，数据可以在客户端和服务器之间进行可靠传输。这三次握手确保了双方都同意建立连接，序列号也得到了确认，以防止数据包的混乱或重复传输。

当通信结束时，TCP还使用四次握手来正常终止连接，以确保双方都知道连接已关闭，避免数据的遗失或重新传输。握手过程在TCP通信中起到非常重要的作用，确保了数据的可靠性和一致性。

cs架构，建立了tcp连接，客户端发送1-10给服务端，丢包率90%，服务端是否能收到，服务端分几次收到。为什么

在一个客户端-服务器（Client-Server，CS）架构下，如果已经建立了TCP连接并且客户端发送1到10的数据给服务端，但存在90%的丢包率，服务端是否能够收到数据以及如何分批次接收数据取决于TCP协议的工作方式和网络状况。

TCP协议在处理丢失数据时有内置的机制，会尽力确保数据的可靠传输。以下是可能发生的情况：

服务端可能收到一部分数据：由于TCP协议的重传机制，客户端发送的数据包可能会因为网络丢包而丢失。在这种情况下，服务端会等待一段时间，然后向客户端请求重传丢失的数据包。服务端可以收到部分数据，但不一定会按顺序接收到所有的数据。

数据包重传：如果服务端没有及时收到某些数据包，它会向客户端发送重传请求，要求客户端重新发送这些数据包。客户端会根据服务端的请求，重新发送那些丢失的数据包。

数据可能会被重新排序：由于数据包可能会以不同的路径到达服务端，它们可能以不同的顺序到达。TCP会负责重新排序这些数据包，以确保它们按照正确的顺序被交付给应用层。

数据丢失概率高：尽管TCP协议会尽力保证数据的可靠传输，但90%的丢包率是相当高的，可能会导致大量的数据包丢失，而服务端需要不断重传请求。这可能会导致延迟和带宽浪费。

总之，服务端有可能会接收到一部分数据，但由于丢包率极高，可能需要进行多次重传和数据包的重新排序，以确保所有的数据都被正确接收。这也会导致较高的网络延迟。为了降低丢包率，可以采取一些措施，如增加网络带宽、使用更可靠的传输媒介或实施错误纠正机制。

解释下Docker有什么作用,和tomcat相比有什么优势

Docker是一个开源的容器化平台，其主要作用是将应用程序及其依赖项打包成容器，从而实现跨平台、可移植、可部署的应用程序环境。以下是Docker的主要作用和与Tomcat相比的优势：

Docker的作用：

容器化应用程序：Docker允许将应用程序及其依赖项打包成容器，包括操作系统、库、配置和应用代码。这使得应用程序可以在不同的环境中保持一致的运行方式。

跨平台可移植性：Docker容器可以在不同的操作系统和云平台上运行，无需担心环境差异。这增加了应用程序的可移植性和可部署性。

隔离和安全性：每个Docker容器都是相互隔离的，有自己的文件系统和进程空间，这增加了安全性，防止应用程序之间的冲突。Docker还提供了安全设置和容器审计功能。

灵活部署：Docker容器可以快速部署、扩展和缩减，允许根据需要动态分配资源。这在云计算环境中非常有用。

版本控制：Docker容器可以版本化，使得应用程序和其依赖项的版本控制更加容易，可回滚到以前的版本。

与Tomcat相比的优势：

应用环境隔离：Docker容器提供更强的环境隔离，每个容器都有自己的文件系统和运行时环境。这可以防止应用程序之间的相互影响，与Tomcat在同一服务器上运行多个应用相比，更安全。

轻量级：Docker容器相对较轻，启动和停止速度快，占用资源少。与传统虚拟机相比，Docker容器更高效。

可移植性：Docker容器可以在不同的环境中轻松部署，而不需要重新配置。Tomcat通常需要针对不同环境进行调整。

自动化部署：Docker容器可以与CI/CD工具集成，实现自动化部署，加速开发和发布流程。

微服务支持：Docker容器适用于微服务架构，允许将应用程序拆分为小的服务单元，更易于维护和扩展。

生态系统：Docker拥有广泛的生态系统，包括Docker Compose、Docker Swarm、Kubernetes等工具，用于容器编排和集群管理。

尽管Docker有许多优势，但Tomcat仍然在特定场景下有其用途，特别是针对Java Web应用程序。在某些情况下，Tomcat可能更容易配置和管理，但Docker在现代应用程序开发和部署中变得越来越重要。选择使用哪种工具应根据具体需求和项目的特点来决定。

List集合

用过哪些List 集合？ArrayList 集合？
ArrayList集合中的扩容机制？
如果要用到大量数据存储？用List存储大量数据要考虑哪些？

List集合是Java中的一种数据结构，用于存储一组元素，并可以根据索引来访问这些元素。List集合允许元素的重复，并维护它们的插入顺序。在Java中，List接口有多种实现类，其中最常用的是ArrayList和LinkedList。

我列举了一些常见的List集合以及有关ArrayList集合的信息：

ArrayList集合：
ArrayList是一个动态数组，它使用数组来存储元素，可以根据需要自动扩展容量。
ArrayList允许元素的重复，并可以根据索引进行快速随机访问。
添加元素时，ArrayList会自动扩容，以适应更多的元素。默认情况下，它会增加50%的容量，以减少频繁的扩容操作。
如果要存储大量数据，特别是在ArrayList中，需要考虑以下因素：

内存消耗：大量数据会占用大量内存，因此需要确保系统有足够的内存可用。在嵌入式或资源有限的环境中，可能需要谨慎考虑内存使用。

性能：ArrayList的动态扩容机制可能会导致性能下降，因为扩容操作需要复制现有数据。如果事先知道要存储大量数据，可以通过初始化ArrayList时指定初始容量来减少扩容次数，提高性能。

遍历和检索：ArrayList允许随机访问，但在大量数据情况下，遍历和检索可能会变得较慢。考虑使用合适的数据结构，如HashMap或TreeMap，以提高查找性能。

数据处理：如果需要频繁地在大量数据上执行添加、删除或其他操作，可能需要考虑使用更适合的数据结构，如LinkedList，以避免复杂的移动元素操作。

数据持久化：对于大量数据的持久化存储，可以考虑使用数据库或文件系统，而不是将所有数据保存在内存中。

综上所述，在处理大量数据时，需要谨慎选择合适的数据结构和优化存储和访问模式，以确保系统性能和内存使用的平衡。ArrayList适用于需要随机访问的情况，但需要特别关注内存消耗和性能问题。
相关阅读:
从Hugging Face上手动下载并加载预训练模型
 【单元测试】--高级主题
 python学习05协程_2
Div3 cf1741
centos操作命令
 Java程序猿搬砖笔记(九)
C的内联函数（C99）
nginx(四十八)HTTP框架提供的变量
 条码录入，使用盘点机PDA，移动便携，将商品本身的条码录入到电脑汉码进销存商品档案里
 Mysql的语句执行很慢，如何分析排查？
原文地址：https://blog.csdn.net/Algernon98/article/details/134226574

手撕代码

相似字符串交换

排序

冒泡排序

插入排序

快速排序

二叉树

层次遍历二叉树

计算机相关

写一个程序判断计算机是大端存储还是小端存储

简答题

进程和线程的差别

判断点在三角形内

绳子分成三段，求最大乘积

两个鸡蛋判断最少从哪层楼扔下来会碎，怎么弄比较好

设计模式了解哪些，MVC解决什么问题

计算机存储类型（寄存器，内存，磁盘）

手机CPU和电脑CPU区别

tcp三次握手，为什么不是两次或者四次

cs架构，建立了tcp连接，客户端发送1-10给服务端，丢包率90%，服务端是否能收到，服务端分几次收到。为什么

解释下Docker有什么作用,和tomcat相比有什么优势

List集合