腾讯游戏服务器外包二面

1.基础问题

2.网络协议

3.数据结构

3.1二叉树的前序遍历

3.2实现二叉树的前序遍历

https://www.nowcoder.com/practice/5e2135f4d2b14eb8a5b06fab4c938635?tpId=295&tqId=2291302&ru=/exam/oj&qru=/ta/format-top101/question-ranking&sourceUrl=%2Fexam%2Foj

3.3 业务问题

3.3.1 Fisher-Yates shuffle算法

C++实现，给你一个数组，将其中元素完全随机打乱返回一个数组，可以施工用rand函数返回随机值
你好！要将一个数组中的元素随机打乱，可以使用Fisher-Yates shuffle算法。该算法基于随机交换数组中的元素，以实现随机打乱数组的目的。具体实现如下：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

// Shuffle the elements of a vector randomly
void shuffle(std::vector<int>& nums) {
    srand(time(nullptr));
    for (int i = nums.size() - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        std::swap(nums[i], nums[j]);
    }
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    shuffle(nums);
    for (int num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

这个函数使用了C++11中的随机数生成器和Fisher-Yates shuffle算法来将数组中的元素随机打乱。在Fisher-Yates shuffle算法中，从数组的最后一个元素开始，随机选择一个元素，并将其与当前位置的元素交换。然后，将当前位置向前移动一位，重复上述步骤，直到整个数组被随机打乱。

3.3.2 轮盘赌算法

C++实现，给定一个数组，数组元素的值就是他的权重，总权重是所有元素权重纸盒，写一个函数，根据根据权重返回随机值，每个元素出现次数符号权重的概率分析
你好！要根据权重返回随机值，可以使用轮盘赌算法（roulette wheel selection algorithm）。该算法基于每个元素的权重，将整个数组看作一个轮盘，并在轮盘上旋转指针，以确定返回哪个元素。具体实现如下：

#include <iostream>
#include <random>
#include <vector>

// Generate a random number between 0 and 1
double random_double() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<double> dis(0.0, 1.0);
    return dis(gen);
}

// Return the index of the randomly selected element based on its weight
int random_weighted_index(const std::vector<double>& weights) {
    double total_weight = 0.0;
    for (double weight : weights) {
        total_weight += weight;
    }
    double r = random_double() * total_weight;
    for (int i = 0; i < weights.size(); i++) {
        r -= weights[i];
        if (r < 0) {
            return i;
        }
    }
    return weights.size() - 1;
}

int main() {
    std::vector<double> weights = {0.1, 0.3, 0.2, 0.4};
    std::vector<int> counts(weights.size(), 0);
    for (int i = 0; i < 10000; i++) {
        int index = random_weighted_index(weights);
        counts[index]++;
    }
    for (int i = 0; i < counts.size(); i++) {
        std::cout << "Element " << i << " appeared " << counts[i] << " times" << std::endl;
    }
    return 0;
}

这个函数使用了C++11中的随机数生成器和轮盘赌算法来根据权重返回随机值。在轮盘赌算法中，首先计算所有元素的权重之和，然后生成一个随机数r，将其乘以总权重，然后遍历数组，每次减去当前元素的权重，直到r小于零为止。此时，返回的就是当前元素的索引。由于每个元素的权重都不同，因此可以确保每个元素出现的次数符合其权重的概率分布。

3.3.3 UUID（通用唯一识别码）算法

C++实现，实现一个函数生成GUID（64位整数全局唯一），这个函数可能在多个机器上运行，每个机器上可能又多个进程跑这个函数，保证每个程序跑出来的GUID一定是唯一的
你好！要实现生成全局唯一的GUID，可以使用UUID（通用唯一识别码）算法。UUID是由128位二进制数表示的，但是可以通过一些算法将其转换为64位整数，以实现更小的存储空间。

以下是一个C++实现UUID算法的示例函数：

#include <iostream>
#include <random>
#include <chrono>

// Generate a random 64-bit integer
uint64_t random_uint64() {
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<uint64_t> dis;
    return dis(gen);
}

// Generate a UUID as a 64-bit integer
uint64_t generate_guid() {
    auto now = std::chrono::system_clock::now().time_since_epoch().count();
    uint64_t rand1 = random_uint64();
    uint64_t rand2 = random_uint64();
    uint64_t uuid = (now << 32) | ((rand1 >> 16) & 0xFFFF);
    uuid = (uuid << 32) | (rand1 & 0xFFFF);
    uuid = (uuid << 16) | ((rand2 >> 48) & 0xFFFF);
    uuid = (uuid << 48) | (rand2 & 0xFFFFFFFFFFFF);
    return uuid;
}

int main() {
    std::cout << generate_guid() << std::endl;
    return 0;
}

这个函数使用了C++11中的随机数生成器和时间戳来生成唯一的UUID。由于使用了随机数，因此可以保证即使在多个机器上运行，每个程序跑出来的GUID也是唯一的。

多个机器上多个程序同时运行也可以保证全局唯一吗

是的，使用UUID算法生成的GUID可以保证在多个机器上多个程序同时运行时也是全局唯一的。这是因为UUID算法使用了时间戳和随机数来生成GUID，即使在不同的机器上，由于时间戳和随机数的不同，生成的GUID也是不同的。因此，可以确保在多个机器上多个程序同时运行时，每个程序跑出来的GUID都是唯一的。