leetcode230：二叉搜索树中第K小的元素

题目链接

leetcode

题目描述

给定一个二叉搜索树的根节点 root 和一个整数 k ，设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

C++ 代码

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
using namespace std;

// 二叉树结点的定义
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

const int NULL_NODE = -1;

// 辅助函数：创建二叉树
TreeNode* createTree(const vector<int>& nums) {
    if (nums.empty()) return nullptr;

    TreeNode* root = new TreeNode(nums[0]);
    queue<TreeNode*> queue;
    queue.push(root);
    int i = 1;
    while (!queue.empty() && i < nums.size()) {
        TreeNode* node = queue.front(); queue.pop();
        if (nums[i] != NULL_NODE) {
            node->left = new TreeNode(nums[i]);
            queue.push(node->left);
        }
        i++;
        if (i < nums.size() && nums[i] != NULL_NODE) {
            node->right = new TreeNode(nums[i]);
            queue.push(node->right);
        }
        i++;
    }

    return root;
}

// 辅助函数：层序遍历打印二叉树
void levelOrderTraversal(TreeNode* root) {
    if (root == nullptr) return;

    queue<TreeNode*> queue;
    queue.push(root);
    while (!queue.empty()) {
        TreeNode* node = queue.front(); queue.pop();
        cout << node->val << " ";
        if (node->left != nullptr) queue.push(node->left);
        if (node->right != nullptr) queue.push(node->right);
    }
    cout << endl;
}

// 辅助函数：释放二叉树
void deleteTree(TreeNode* root) {
    if (root == nullptr) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
}

/*
    递归实现
    中序遍历整棵二叉搜索树，数组记录结点的值，输出第 k 个结点。
    
    时间复杂度：O(n)
        其中 n 为二叉树结点的数目。遍历整棵二叉搜索树。
    空间复杂度：O(n)
*/
class Solution_0 {
public:
    int kthSmallest(TreeNode* root, int k) {
        vector<int> res;
        dfs(root, res);

        return res[k-1];
    }

    void dfs(TreeNode* node, vector<int>& res) {
        if (node == nullptr) {
            return;
        }

        dfs(node->left, res);
        res.push_back(node->val);
        dfs(node->right, res);
    }
};

/*
    递归实现，优化空间

    时间复杂度：O(n)
        其中 n 为二叉树结点的数目。需要遍历整棵二叉搜索树。
    空间复杂度：O(logn)
        在最坏的情况下，递归栈的深度可以达到树的高度。
        对于平衡二叉树，空间复杂度为 O(logn)。
*/
class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        this->k = k;
        dfs(root);

        return res;
    }

    void dfs(TreeNode* node) {
        if (node == nullptr) {
            return;
        }

        dfs(node->left);
        if (--k == 0) {
            res = node->val;
        }
        dfs(node->right);
    }

private:
    int res, k;
};

/*
    迭代实现
    在栈的辅助下，不用遍历整个树，找到答案后就停止。

    时间复杂度：O(n)
        其中 n 是二叉树的结点数量。
    空间复杂度：O(logn)
*/
class Solution_2 {
public:
    int kthSmallest(TreeNode* root, int k) {
        stack<TreeNode*> stk;

        while (root || stk.size()) {
            while (root) {
                stk.push(root);
                root = root->left;
            }
            root = stk.top(); stk.pop();
            if (--k == 0) {
                return root->val;
            }
            root = root->right;
        }

        return -1;
    }
};

// 辅助函数：打印数组
void printArray(const vector<int>& nums) {
    cout << "[";
    for (size_t i = 0; i < nums.size(); i++) {
        cout << nums[i];
        if (i != nums.size() - 1) cout << ",";
    }
    cout << "]" << endl;
}

// 辅助函数：打印二维数组
void printArray(const vector<vector<int>>& nums) {
    cout << "[";
    for (size_t i = 0; i < nums.size(); i++) {
        cout << "[";
        for (size_t j = 0; j < nums[i].size(); j++) {
            cout << nums[i][j];
            if (j != nums[i].size() - 1) cout << ",";
        }
        cout << "]";
        if (i != nums.size() - 1) cout << ",";
    }
    cout << "]" << endl;
}

int main() {
    Solution solution;
    vector<vector<int>> root_cases = {
        {3,1,4,NULL_NODE,2},
        {5,3,6,2,4,NULL_NODE,NULL_NODE,1},
    };
    vector<int> k_cases = {
        1, 3
    };

    for (int i = 0; i < root_cases.size(); i++) {
        auto& nums = root_cases[i];
        int k = k_cases[i];
        cout << "Input: ";
        printArray(nums);

        // 创建二叉树
        TreeNode* root = createTree(nums);
        // 获取第 K 小的元素
        int result = solution.kthSmallest(root, k);
        cout << "Output: " << result << endl;

        // 释放内存
        deleteTree(root);
    }

    return 0;
}