面试真题 | 华为OD C++[20241008]

一、机试（380）

1. 机场航班调度

算法题：机场航班调度

问题描述：

机场航班调度是一个复杂的优化问题，涉及多个航班的起飞和降落时间、跑道使用、燃油效率、乘客舒适度等多个因素。为了简化这个问题，我们可以考虑一个基本的版本：给定一系列航班的到达时间、准备时间（从到达停机坪到准备好起飞的时间）和飞行时间（从起飞到目的地的时间），要求计算并输出所有航班的最早起飞时间和到达目的地的时间，同时确保同一时间只有一个航班在使用跑道。

解决方案：

我们可以使用贪心算法来解决这个问题。贪心算法在每一步都做出在当前看来最好的选择，从而希望这样的局部最优选择能够导致全局最优解。

1. 排序：首先，根据航班的到达时间对它们进行排序。如果到达时间相同，则按照准备时间排序。

2. 计算起飞时间：初始化一个当前时间变量为0（表示机场刚开始运作的时间）。遍历排序后的航班列表，对于每个航班，计算其最早起飞时间（到达时间 + 准备时间），并确保它不早于当前时间。然后，更新当前时间为该航班的起飞时间加上飞行时间（即下一个航班可以使用跑道的最早时间）。

3. 输出结果：遍历航班列表，输出每个航班的最早起飞时间和到达目的地的时间（起飞时间 + 飞行时间）。

代码实现（伪代码）：

struct Flight {
    int arrivalTime;
    int preparationTime;
    int flightTime;
    int earliestTakeoffTime;
    int arrivalDestinationTime;
};

// 比较函数，用于按到达时间排序航班
bool compareFlights(const Flight& a, const Flight& b) {
    if (a.arrivalTime != b.arrivalTime) {
        return a.arrivalTime < b.arrivalTime;
    } else {
        return a.preparationTime < b.preparationTime;
    }
}

void scheduleFlights(vector<Flight>& flights) {
    // 按到达时间排序航班
    sort(flights.begin(), flights.end(), compareFlights);

    int currentTime = 0;

    for (auto& flight : flights) {
        // 计算最早起飞时间
        flight.earliestTakeoffTime = max(currentTime, flight.arrivalTime) + flight.preparationTime;
        // 更新当前时间为下一个航班可以使用跑道的时间
        currentTime = flight.earliestTakeoffTime + flight.flightTime;
        // 计算到达目的地的时间
        flight.arrivalDestinationTime = flight.earliestTakeoffTime + flight.flightTime;
    }
}

// 示例使用
int main() {
    vector<Flight> flights = {
        {1, 2, 3},
        {0, 1, 4},
        {2, 3, 1}
    };

    scheduleFlights(flights);

    for (const auto& flight : flights) {
        cout << "Flight earliest takeoff: " << flight.earliestTakeoffTime
             << ", arrival at destination: " << flight.arrivalDestinationTime << endl;
    }

    return 0;
}

面试官追问及回答：

追问1：

• 问题：如果跑道有两条，如何修改算法来支持双跑道调度？

回答： 要支持双跑道调度，我们可以将航班分为两组，并分别使用两个独立的贪心算法来调度它们。这可以通过以下方式实现：

1. 将航班列表分成两个子集，可以使用简单的轮询方法（例如，第一个航班到第一个子集，第二个航班到第二个子集，依此类推），或者基于某种更复杂的启发式策略（例如，根据航班的飞行时间或准备时间来分配）。

2. 对每个子集分别应用上述的贪心算法来调度航班。

3. 需要注意的是，虽然每个子集内部是独立调度的，但两个子集之间仍然需要协调以避免跑道冲突。这可以通过在每个子集内部维护一个当前时间变量，并确保一个子集的当前时间不会影响到另一个子集的调度来实现。

追问2：

• 问题：如果考虑到航班之间的优先级（例如，某些航班需要优先起飞），如何修改算法来处理这种情况？

回答： 要考虑到航班之间的优先级，我们可以在排序航班时引入一个优先级字段，并根据该字段来调整排序规则。具体实现如下：

1. 在Flight结构体中添加一个优先级字段（例如，一个整数表示优先级的高低）。

2. 修改比较函数compareFlights，使其首先根据优先级对航班进行排序。如果优先级相同，则再根据到达时间和准备时间进行排序。

3. 重新运行贪心算法，现在它会根据优先级、到达时间和准备时间来调度航班。

需要注意的是，引入优先级可能会导致某些低优先级的航班被延迟较长时间，因此在实际应用中需要仔细权衡优先级的设定对整体调度效率的影响。

追问3：

• 问题：如果机场有多个停机坪，并且每个停机坪可以同时处理多个航班的准备工作，如何修改算法来支持这种情况？

回答： 要支持多个停机坪和并行准备工作，我们可以将问题建模为一个更复杂的资源分配和优化问题。一个可能的解决方案是使用图论和网络流算法来模拟停机坪和航班之间的依赖关系，并找到最优的调度策略。然而，这种方法的计算复杂度较高，可能不适合实时调度。

为了简化问题并保持实时性，我们可以采用以下启发式方法：

1. 将停机坪视为资源池，每个停机坪可以同时处理多个航班的准备工作。

2. 当一个航班到达时，为其分配一个可用的停机坪（如果有多个停机坪可用，则可以选择一个负载最低的停机坪）。

3. 跟踪每个停机坪上当前正在准备的航班以及它们的预计完成时间。

4. 在调度航班起飞时，选择最早可用的航班（即其准备时间最早结束的航班）进行起飞，并确保它符合跑道的调度规则。

5. 不断更新停机坪和跑道的状态，并根据需要调整调度策略以应对新的航班到达和跑道使用情况的变化。

需要注意的是，这种方法是一种启发式方法，它可能无法找到全局最优解，但在实际应用中通常能够提供一个合理且可行的调度方案。

2. 机器人搬砖

要实现一个详细的算法来解决“机器人搬砖”问题，我们需要将问题分解为几个关键步骤，并为每个步骤提供具体的实现和解释。由于这个问题涉及到图的构建、最短路径搜索以及路径细化等多个方面。

步骤1：定义数据结构和全局变量

首先，我们需要定义一些数据结构和全局变量来存储砖块、节点、边以及机器人的状态。

#include <iostream>
#include <vector>
#include <cmath>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <limits>

// 定义砖块结构体
struct Brick {
    int x1, y1, x2, y2; // 砖块的左上角和右下角坐标
};

// 定义节点结构体（图的顶点）
struct Node {
    int x, y; // 节点的坐标
    double gCost; // 从起点到该节点的最短路径成本
    Node* parent; // 指向父节点的指针，用于路径重构
    bool visited; // 标记节点是否已被访问

    // 构造函数
    Node(int x, int y) : x(x), y(y), gCost(std::numeric_limits<double>::infinity()), parent(nullptr), visited(false) {}
};

// 定义边结构体（图的边）
struct Edge {
    Node* from, *to; // 边的起点和终点
    double weight;   // 边的权重（距离）

    // 构造函数
    Edge(Node* f, Node* t, double w) : from(f), to(t), weight(w) {}
};

// 全局变量
std::vector<Brick> bricks; // 存储所有砖块
std::unordered_map<std::pair<int, int>, Node*> nodeMap; // 用于快速查找节点
std::vector<Edge*> edges;  // 存储所有边
Node* startNode;           // 起始节点
Node* goalNode;            // 目标节点

步骤2：构建图

接下来，我们需要遍历砖块区域，构建图的节点和边。为了简化问题，我们可以将每个砖块的中心点作为节点，并将相邻砖块的中心点之间创建边。边的权重可以是欧几里得距离。

void buildGraph() {
    // 遍历砖块，为每个砖块创建一个节点（这里以中心点为例）
    for (auto& brick : bricks) {
        int centerX = (brick.x1 + brick.x2) / 2;
        int centerY = (brick.y1 + brick.y2) / 2;
        nodeMap[{centerX, centerY}] = new Node(centerX, centerY);
    }

    // 为相邻砖块的中心点之间创建边（这里简化处理，只考虑水平和垂直相邻）
    for (auto& [key, node] : nodeMap) {
        int x = key.first;
        int y = key.second;

        // 检查上方是否有相邻砖块
        if (nodeMap.find({x, y - 1}) != nodeMap.end()) {
            edges.push_back(new Edge(node, nodeMap[{x, y - 1}], std::abs(y - (y - 1))));
        }

        // 检查下方是否有相邻砖块
        if (nodeMap.find({x, y + 1}) != nodeMap.end()) {
            edges.push_back(new Edge(node, nodeMap[{x, y + 1}], std::abs(y - (y + 1))));
        }

        // 检查左侧是否有相邻砖块
        if (nodeMap.find({x - 1, y}) != nodeMap.end()) {
            edges.push_back(new Edge(node, nodeMap[{x - 1, y}], std::abs(x - (x - 1))));
        }

        // 检查右侧是否有相邻砖块
        if (nodeMap.find({x + 1, y}) != nodeMap.end()) {
            edges.push_back(new Edge(node, nodeMap[{x + 1, y}], std::abs(x - (x + 1))));
        }
    }

    // 设置起始节点和目标节点（这里假设起始节点在(0,0)，目标节点在(goalX, goalY)）
    startNode = nodeMap[{0, 0}]; // 需要根据实际情况设置
    goalNode = nodeMap[{/*goalX*/, /*goalY*/}]; // 需要根据实际情况设置
}

注意：这里的图构建过程非常简化，只考虑了水平和垂直相邻的砖块。在实际应用中，可能需要更复杂的逻辑来处理砖块之间的连接，特别是当砖块不是规则排列或存在不同大小和方向时。此外，起始节点和目标节点的设置也需要根据具体问题的要求来确定。

步骤3：最短路径搜索

现在，我们可以使用Dijkstra算法来找到从起始节点到目标节点的最短路径。Dijkstra算法是一种贪心算法，它逐步扩展最短路径，直到找到包含目标节点的路径。

void dijkstra() {
    // 初始化优先队列和访问标记
    std::priority_queue<std::pair<double, Node*>, std::vector<std::pair<double, Node*>>, std::greater<>> pq;
    std::unordered_set<Node*> visited;

    // 设置起始节点的成本为0，并将其加入优先队列
    startNode->gCost = 0;
    pq.push({0, startNode});

    // Dijkstra算法的主循环
    while (!pq.empty()) {
        auto [cost, currentNode] = pq.top();
        pq.pop();

        // 如果当前节点已经被访问过，则跳过
        if (visited.find(currentNode) != visited.end()) {
            continue;
        }

        // 标记当前节点为已访问
        visited.insert(currentNode);

        // 遍历当前节点的所有邻居
        for (auto edge : edges) {
            if (edge->from == currentNode) {
                Node* neighbor = edge->to;

                // 计算通过当前节点到达邻居的成本
                double newCost = currentNode->gCost + edge->weight;

                // 如果找到更短的路径，则更新邻居的成本和父节点
                if (newCost < neighbor->gCost) {
                    neighbor->gCost = newCost;
                    neighbor->parent = currentNode;
                    pq.push({newCost, neighbor});
                }
            }
        }
    }
}

步骤4：路径重构

最后，我们需要根据Dijkstra算法计算出的成本数组和父节点指针来重构从起始节点到目标节点的最短路径。

std::vector<Node*> reconstructPath() {
    std::vector<Node*> path;
    Node* currentNode = goalNode;

    // 从目标节点开始，沿着父节点指针回溯到起始节点
    while (currentNode != nullptr) {
        path.push_back(currentNode);
        currentNode = currentNode->parent;
    }

    // 反转路径，使其从起始节点到目标节点
    std::reverse(path.begin(), path.end());

    return path;
}

步骤5：路径细化（可选）

如果我们需要机器人沿着砖块的边缘移动，而不是直接从一个砖块的中心点到另一个砖块的中心点，我们可能需要对路径进行细化。这通常涉及到更复杂的几何计算，并且可能需要额外的数据结构来存储砖块的边缘信息。由于这个问题的复杂性，这里不展开实现路径细化的具体细节。

完整代码和测试

将上述步骤整合到一个完整的程序中，并添加适当的测试代码来验证算法的正确性。

int main() {
    // 添加砖块到bricks向量中（这里需要手动设置砖块的位置和大小）
    // ...

    // 构建图
    buildGraph();

    // 执行Dijkstra算法
    dijkstra();

    // 重构路径
    std::vector<Node*> path = reconstructPath();

    // 输出路径
    for (auto node : path) {
        std::cout << "(" << node->x << ", " << node->y << ") -> ";
    }
    std::cout << "Goal\n";

    // 清理内存（释放动态分配的节点和边）
    // ...

    return 0;
}

注意：上述代码示例中的bricks向量、起始节点和目标节点的设置都需要根据具体问题的要求来填充和设置。此外，由于代码示例中使用了动态内存分配（new关键字），因此在实际应用中需要确保在程序结束时释放所有动态分配的内存，以避免内存泄漏。这可以通过在main函数的末尾添加适当的清理代码来实现，或者使用智能指针等现代C++特性来自动管理内存。

最后，需要注意的是，这个实现是基于简化的假设和条件（如砖块中心点作为节点、只考虑水平和垂直相邻的砖块等）。在实际应用中，可能需要更复杂的逻辑来处理不同大小、形状和方向的砖块，以及更

3. 数据单元的变化替换

算法题：数据单元的变化替换

问题描述：

在一个数据结构中（例如，一个数组或链表），每个数据单元包含一个整数值。现在要求你实现一个函数，该函数能够遍历整个数据结构，并查找所有等于某个给定值的单元，将这些单元的值替换为另一个给定的新值。同时，函数需要返回被替换的数据单元的数量。

解决方案：

这个问题可以通过一次遍历数据结构来解决。我们可以使用指针或迭代器来遍历数组或链表，并在遍历过程中检查每个数据单元的值是否等于给定的目标值。如果相等，则将其替换为新值，并增加计数器。

以下是一个基于数组的解决方案的C++代码示例：

#include <iostream>
#include <vector>

int replaceValue(std::vector<int>& data, int oldValue, int newValue) {
    int count = 0;
    for (auto& value : data) {
        if (value == oldValue) {
            value = newValue;
            ++count;
        }
    }
    return count;
}

int main() {
    std::vector<int> data = {1, 2, 3, 2, 4, 2, 5};
    int oldValue = 2;
    int newValue = 99;
    
    int replacedCount = replaceValue(data, oldValue, newValue);
    
    std::cout << "Replaced " << replacedCount << " occurrences of " << oldValue << " with " << newValue << "." << std::endl;
    for (const auto& value : data) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

对于链表，解决方案会稍微复杂一些，因为需要处理节点的指针操作，但基本原理是相同的。

面试官追问及回答：

追问1：

• 问题：如果数据结构是一个双向链表，你如何实现这个函数？

回答： 对于双向链表，我们需要定义一个节点结构体，其中包含数据域和前驱、后继指针。然后，我们可以从头节点开始遍历链表，检查每个节点的值，如果等于给定值，则进行替换，并增加计数器。由于双向链表可以双向遍历，我们还可以考虑从尾节点开始遍历，但这对于本问题来说并不是必需的。

以下是一个基于双向链表的解决方案的C++代码示例（简化版，不包含内存管理和链表构建代码）：

struct Node {
    int data;
    Node* prev;
    Node* next;
    
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

int replaceValueInDoublyLinkedList(Node* head, int oldValue, int newValue) {
    int count = 0;
    Node* current = head;
    while (current != nullptr) {
        if (current->data == oldValue) {
            current->data = newValue;
            ++count;
        }
        current = current->next;
    }
    return count;
}

追问2：

• 问题：如果要求替换操作是线程安全的，并且数据结构是在多线程环境中被多个线程同时访问的，你如何实现这个函数？

回答： 在多线程环境中实现线程安全的替换操作，我们需要使用同步机制来确保在访问和修改数据结构时不会发生数据竞争。对于数组，可以使用互斥锁（如std::mutex）来保护整个数组或数组的一部分。对于链表，可以使用更细粒度的锁，如每个节点一个锁，或者使用一个全局锁（但这可能会降低并发性）。

然而，更常见且高效的做法是使用读写锁（如std::shared_mutex），它允许多个读线程同时访问数据结构，但写线程（进行替换操作的线程）在写入时需要独占访问权。

以下是一个基于读写锁的数组替换操作的伪代码示例：

#include <iostream>
#include <vector>
#include <shared_mutex>

std::vector<int> data;
std::shared_mutex rw_mutex;

int replaceValueThreadSafe(int oldValue, int newValue) {
    std::unique_lock<std::shared_mutex> write_lock(rw_mutex); // 获取写锁
    int count = 0;
    for (auto& value : data) {
        if (value == oldValue) {
            value = newValue;
            ++count;
        }
    }
    return count;
}

// 在多线程环境中调用replaceValueThreadSafe函数时，需要确保在调用前后没有其他线程对data进行写操作。

注意，在实际应用中，还需要考虑锁的粒度、死锁避免、性能优化等问题。

追问3：

• 问题：如果数据单元不仅仅是整数值，而是一个复杂的结构体，你如何实现这个函数？

回答： 如果数据单元是一个复杂的结构体，我们仍然可以使用类似的遍历和替换逻辑。不过，此时我们需要比较和替换的是结构体中的某个特定字段，而不是整个结构体。

假设我们有一个结构体DataUnit，其中包含一个需要替换的整数字段value：

struct DataUnit {
    int value;
    // 其他字段...
    
    DataUnit(int val) : value(val) {}
};

int replaceValueInStructArray(std::vector<DataUnit>& data, int oldValue, int newValue) {
    int count = 0;
    for (auto& unit : data) {
        if (unit.value == oldValue) {
            unit.value = newValue;
            ++count;
        }
    }
    return count;
}

在这个例子中，我们遍历了一个DataUnit类型的数组，并替换了每个单元中value字段等于给定值的单元。其他字段保持不变。

二、技术一面

1. 自我介绍

2. TCP/IP四层架构

TCP/IP四层架构

TCP/IP四层架构是计算机网络领域中广泛应用的分层模型，它简化了网络通信的复杂性，提高了网络的可靠性和灵活性。

TCP/IP四层架构概述

TCP/IP四层架构从上到下依次为：应用层、传输层、网络层和网络接口层。每层都承担着特定的功能，共同确保网络通信的顺畅进行。

1. 应用层：

   • 功能：提供网络服务访问，如电子邮件、文件传输、网页浏览等。
   • 协议：HTTP、FTP、SMTP、DNS等。
   • 作用：与用户直接交互，处理用户请求，并将处理结果返回给用户。

2. 传输层：

   • 功能：负责端到端的通信和数据传输，确保数据包的完整性和可靠性。
   • 协议：TCP（传输控制协议）、UDP（用户数据报协议）。
   • 作用：TCP提供可靠的、面向连接的传输服务，通过序列号、确认机制和重传机制保证数据完整性；UDP则提供无连接的、不可靠但速度快的传输服务。

3. 网络层：

   • 功能：负责主机到主机之间的通信，即数据包从源网络传输到目的网络的过程。
   • 协议：IP（互联网协议）、ICMP（互联网控制消息协议）等。
   • 作用：定义数据包的传输路径，通过路由器进行路径选择，实现跨网络的通信。

4. 网络接口层（包括数据链路层和物理层）：

   • 功能：负责将数据包发送到物理网络上，并接收从物理网络上传来的数据包。
   • 协议：以太网协议、Wi-Fi协议等。
   • 作用：处理数据帧的封装、解封装、错误检测、流量控制等，确保数据包在物理网络上的正确传输。

面试官追问及回答

追问1：

• 问题：TCP/IP四层架构与OSI七层模型有何异同？

回答：

• 相同点：两者都是描述网络通信的分层模型，都旨在简化网络通信的复杂性。
• 不同点：OSI七层模型更为详细和复杂，包含了表示层和会话层，而TCP/IP四层模型则更为简洁和实用，将表示层和会话层的功能合并到了应用层。此外，OSI模型更多地是一种理论框架，而TCP/IP模型则更贴近实际网络协议的设计和实现。

追问2：

• 问题：TCP协议是如何保证数据传输的可靠性的？

回答：

• TCP协议通过一系列机制来保证数据传输的可靠性。首先，TCP使用序列号对数据包进行编号，以便接收端能够按照正确的顺序重组数据。其次，TCP采用确认应答机制，接收端在收到数据包后会向发送端发送确认报文，以确保数据包已被正确接收。如果发送端在一定时间内未收到确认报文，则会认为数据包丢失并重传该数据包。此外，TCP还使用滑动窗口机制来控制发送端和接收端之间的数据传输速率，以避免网络拥塞和数据丢失。

追问3：

• 问题：在TCP/IP四层架构中，网络接口层是如何处理数据包的？

回答：

• 在TCP/IP四层架构中，网络接口层负责处理数据包在物理网络上的传输。具体来说，网络接口层会将来自传输层的数据包封装成数据帧，并添加必要的头部和尾部信息以便在物理网络上传输。然后，网络接口层会将数据帧发送到物理网络上，如以太网或Wi-Fi。在接收端，网络接口层会接收从物理网络上传来的数据帧，并对其进行解封装以提取出数据包。在解封装过程中，网络接口层还会进行错误检测和数据完整性验证，以确保数据包在传输过程中未受到损坏。如果检测到错误，网络接口层会丢弃该数据包并向发送端发送错误报告。

3. TCP使用的拥塞控制算法

TCP使用的拥塞控制算法是一套基于线增积减模式的多样化网络拥塞控制方法，主要包括慢启动、拥塞避免、快速重传和快速恢复四个部分。以下是对这四个部分的详细解释：

1. 慢启动：

   • 原理：慢启动算法在TCP连接刚建立时，用于探测网络的拥塞程度。它通过设置较小的初始拥塞窗口（cwnd），并逐步增加，以避免数据过快注入网络导致拥塞。
   • 过程：在慢启动阶段，每当发送方收到一个对新的报文段的确认后，拥塞窗口就会增加一个最大报文段MSS的数值。这样，拥塞窗口在每次往返时间（RTT）内都会成倍增长，直到达到慢启动阈值（ssthresh）或发生丢包为止。
   • 目的：通过逐步增加发送数据量，慢启动算法旨在避免一开始就发送过多的数据导致网络拥塞。

2. 拥塞避免：

   • 原理：拥塞避免算法在慢启动阶段之后开始工作，它通过更平缓的方式控制cwnd的增长，以防止网络拥塞。
   • 过程：在拥塞避免阶段，每当收到一个确认报文时，cwnd会增加1/cwnd个MSS（即线性增长），而不是像慢启动阶段那样成倍增长。这样，cwnd的增长速度会随着其值的增加而逐渐减缓。
   • 目的：通过控制cwnd的增长速度，拥塞避免算法旨在保持网络的稳定性，避免因为cwnd过快增长而导致的网络拥塞。

3. 快速重传：

   • 原理：快速重传算法利用TCP的确认机制，在检测到丢包时迅速重传丢失的数据包。
   • 过程：当发送方连续收到三个或三个以上的重复确认报文（即duplicated ACK）时，它会认为有数据包丢失，并立即重传该数据包。这样做可以减少因为超时而导致的数据传输延迟。
   • 目的：通过快速重传丢失的数据包，快速重传算法旨在提高网络的效率和稳定性。

4. 快速恢复：

   • 原理：快速恢复算法是在快速重传之后使用的一种拥塞控制算法，它旨在避免因为超时而导致的拥塞窗口重新从1开始增长。
   • 过程：在快速恢复阶段，发送方会将慢启动阈值（ssthresh）减半，并重传丢失的数据包。然后，它将拥塞窗口设置为ssthresh加上三个报文段的大小，并继续发送数据。当收到新的确认报文时，发送方会退出快速恢复阶段，并将拥塞窗口设置为ssthresh，然后进入拥塞避免阶段。
   • 目的：通过快速恢复算法，发送方可以在不重置拥塞窗口的情况下恢复数据传输，从而提高网络的效率和稳定性。

面试官追问及回答：

1. 面试官追问：TCP拥塞控制算法中的慢启动和拥塞避免是如何协同工作的？

   • 回答：慢启动和拥塞避免是TCP拥塞控制算法中的两个重要阶段。在TCP连接刚建立时，慢启动算法会逐步增加发送数据量以探测网络的拥塞程度。当拥塞窗口达到慢启动阈值或发生丢包时，拥塞避免算法开始工作，通过更平缓的方式控制cwnd的增长以防止网络拥塞。这两个阶段协同工作，旨在保持网络的稳定性和效率。

2. 面试官追问：TCP拥塞控制算法中的快速重传和快速恢复是如何提高网络效率的？

   • 回答：快速重传和快速恢复是TCP拥塞控制算法中用于处理丢包的两个重要机制。当发送方连续收到三个或三个以上的重复确认报文时，快速重传算法会立即重传丢失的数据包，以减少因为超时而导致的数据传输延迟。然后，快速恢复算法会调整慢启动阈值和拥塞窗口的大小，以避免因为超时而导致的拥塞窗口重新从1开始增长。这两个机制协同工作，可以显著提高网络的效率和稳定性。

3. 面试官追问：在实际应用中，TCP拥塞控制算法可能会遇到哪些挑战？

   • 回答：在实际应用中，TCP拥塞控制算法可能会遇到多种挑战。例如，网络环境的复杂性可能导致拥塞控制算法难以准确判断网络的拥塞程度；不同设备的性能和配置差异也可能影响拥塞控制算法的效果；此外，一些恶意行为（如网络攻击）也可能对拥塞控制算法造成干扰。因此，在实际应用中，需要根据具体情况对TCP拥塞控制算法进行调整和优化。

4. 设计模式，设计原则

设计模式与设计原则

设计模式

设计模式是在软件设计中反复出现的问题的解决方案。它们不是代码片段，而是解决问题的思路和方法。常见的设计模式分为三类：创建型模式、结构型模式和行为型模式。

1. 创建型模式：用于创建对象，主要解决对象的实例化问题。包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。

   • 单例模式：确保一个类只有一个实例，并提供一个全局访问点。适用于需要控制资源访问的场景，如日志记录器、配置管理器等。

   • 工厂方法模式：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。

   • 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用于需要创建一组相关对象且这些对象之间存在紧密关系的场景。

   • 建造者模式：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。适用于需要逐步构建复杂对象的场景。

   • 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。适用于创建成本较高或创建过程复杂的对象。

2. 结构型模式：用于处理类或对象之间的组合关系，主要解决对象的组合问题。包括适配器模式、桥接模式、装饰模式、外观模式、享元模式和代理模式。

   • 适配器模式：将一个类的接口转换成客户端所期待的另一种接口形式。适用于需要将一个类的接口转换为另一个不兼容的接口的场景。

   • 桥接模式：将抽象部分与实现部分分离，使它们都可以独立地变化。适用于抽象和实现之间存在多个维度变化的场景。

   • 装饰模式：动态地给一个对象添加一些额外的职责。适用于在不修改原有类结构的情况下扩展类的功能。

   • 外观模式：提供一个统一的接口，用来访问子系统中的一群接口。适用于简化复杂系统的接口，提供一个易于使用的入口。

   • 享元模式：运用共享技术有效地支持大量细粒度对象的复用。适用于需要创建大量相同或相似对象的场景。

   • 代理模式：为其他对象提供一种代理以控制对这个对象的访问。适用于需要在直接访问对象时增加额外的控制或功能的场景。

3. 行为型模式：用于描述类或对象之间的交互关系，主要解决对象之间的通信问题。包括策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、状态模式、中介者模式、访问者模式和备忘录模式。