Create Convert Sorted Array to Binary Search Tree.md

[irohafternoon]

This Problem
Convert Sorted Array to Binary Search Tree
Next Problem
Path Sum

[nodchip]

+ と 1 の間にスペースを空けることをお勧めいたします。

[nodchip]

人によっては std::pair や std::tuple を避ける場合があります。理由は、何番目に何の値が入っているか分かりにくく感じるためです。代わりに構造体を定義し、その中に値を格納します。
スコープが短い場合は問題ないと思います。また、今回は構造化束縛で front() の戻り値を受け、変数名が書かれているので問題ないと思います。
チームの平均的な書き方に合わせることをお勧めいたします。

[irohafternoon]

ありがとうございます。
私の感想としても、構造化束縛で変数名が分かるのでtupleを使って良いかなと考えていました。
実務ではチームの方針を確認するようにいたします。

[nodchip]

TreeNode** でなく TreeNode* でも実装できるでしょうか。

[irohafternoon]

コメントありがとうございます。
こちらのように書きました

#include <vector>
#include <queue>

class Solution {
public:
    TreeNode* sortedArrayToBST(const std::vector<int>& nums) {
        if (nums.empty()) {
            return nullptr;
        }
        std::queue<std::tuple<int, int, TreeNode*>> nodes_for_BST;
        TreeNode* root = new TreeNode();
        nodes_for_BST.emplace(0, nums.size() - 1, root);
        while (!(nodes_for_BST).empty()) {
            auto [left_index, right_index, node] = nodes_for_BST.front();
            nodes_for_BST.pop();
            int mid_index = (left_index + right_index) / 2;
            node->val = nums[mid_index];
            if (left_index <= mid_index - 1) {
                node->left = new TreeNode();
                nodes_for_BST.emplace(left_index, mid_index - 1, node->left);
            }
            if (mid_index + 1 <= right_index) {
                node->right = new TreeNode();
                nodes_for_BST.emplace(mid_index + 1, right_index, node->right);
            }
        }
        return root;
    }
};

[nodchip]

右半開区間でも実装できるでしょうか。

[irohafternoon]

ありがとうございます。
右半開区間の場合、indexの満たすべき条件は left_index < right_indexになります。また、right_indexの初期値がnums.size()となります。
以下のように書きました

class Solution {
public:
    TreeNode* sortedArrayToBST(const std::vector<int>& nums) {
        return ContructBST(nums, 0, nums.size());
    }
private:
    TreeNode* ContructBST(const std::vector<int>& nums, int left_index, int right_index) {
        if(!(left_index < right_index)) {
            return nullptr;
        }
        int mid_index = (left_index + right_index) / 2;
        TreeNode* node = new TreeNode(nums[mid_index]);
        node->left = ContructBST(nums, left_index, mid_index);
        node->right = ContructBST(nums, mid_index + 1, right_index);
        return node;
    }
};

[oda]

このあたりでいいかと思います。

[oda]

手の運動は、そうですね。少々面倒だとしても手を動かせば解決できるなら、ひとまず手を動かしながら考えます。

たとえば、「O(n!) なアルゴリズムがあります。n がいくらくらいまで計算できそうですか?」というときに、「いいから1から10まで掛け算しよう。小さすぎたら20までかけよう。」みたいな話です。

[oda]

これ、メモリーリークしていませんか。

TreeNode** を使うならば、私は pop した後に new することを想定しました。

あと、(*ptr_to_node) が多いので、変数に置いてもよいかと思います。

[irohafternoon]

ありがとうございます。
おっしゃる通り、先のコードでは、newで確保したメモリのノードが条件を満たさないときにnullptrに書き換えており、newで確保したメモリの番地の情報がわからなくなりdeleteできなくなり、メモリリークすると理解しました。

順番が逆で、一旦nullptrにした後、有効なノードであれば、ダブルポインタを使って、newで新たに確保したメモリの番地に書き換えるべきでした。
(*ptr_to_node)をnodeという変数において、以下のように書きました

#include <queue>
#include <vector>

class Solution {
public:
    TreeNode* sortedArrayToBST(const std::vector<int>& nums) {
        //tuple = (left_index, right_index, ptr_to_node)
        std::queue<std::tuple<int, int, TreeNode**>> nodes_for_BST;
        TreeNode* root = new TreeNode();
        nodes_for_BST.emplace(0, nums.size() - 1, &root);
        while (!nodes_for_BST.empty()) {
            auto [left_index, right_index, ptr_to_node] = nodes_for_BST.front();
            nodes_for_BST.pop();
            if (!(left_index <= right_index)) {
                continue;
            }
            int mid_index = (left_index + right_index) / 2;
            *ptr_to_node = new TreeNode(nums[mid_index]);
            TreeNode*  node = *ptr_to_node;
            nodes_for_BST.emplace(left_index, mid_index - 1, &(node->left));
            nodes_for_BST.emplace(mid_index + 1, right_index, &(node->right));
        }
        return root;
    }
};