C++的数据结构(九）： 笛卡尔树

        笛卡尔树（Cartesian Tree）是一种特殊的二叉树，其每个节点的键值（key）满足二叉搜索树的性质，即左子树上所有节点的键值小于根节点的键值，右子树上所有节点的键值大于根节点的键值。与此同时，每个节点的值（value）又满足堆的性质，即父节点的值总是大于（或小于）其子节点的值。这种双重性质使得笛卡尔树在数据结构和算法领域中具有广泛的应用。

        

        笛卡尔树的构建过程相对直观。给定一个键值（key）和值（value）组成的序列，我们可以通过一次线性扫描来构建对应的笛卡尔树。具体步骤如下： 

        1. 初始化一个空栈，用于保存当前已构建好的树的一部分。
        2. 遍历键值-值序列，对于每个元素，执行以下操作：
                   - 若栈为空，则当前元素作为根节点入栈。
                   - 否则，比较栈顶元素的值与当前元素的值：
                     - 若当前元素的值小于等于栈顶元素的值，则弹出栈顶元素，并重复此步骤，直到找到一个栈顶元素的值小于当前元素的值或栈为空。
                     - 将当前元素作为新的节点，其左子树为最后弹出的那个元素（如果存在的话），右子树为原栈顶元素的右子树（如果存在的话），然后将新节点入栈。

        通过上述步骤，我们可以保证构建出的笛卡尔树满足键值满足二叉搜索树的性质，值满足堆的性质。

        假设我们有一个键值-值序列：[(3, 2), (1, 4), (4, 1), (1, 5), (9, 2), (2, 6), (5, 3), (3, 5)]。根据笛卡尔树的构建原理，我们可以得到如下的笛卡尔树：

     5(3)
     /     \
    1(5)    9(2)
   /  \       \
  3(2) 4(1)    2(6)
 /               \
1(4)            3(5)

        在这个例子中，每个括号里的数字表示节点的值（value），括号外的数字表示节点的键值（key）。可以看出，键值满足二叉搜索树的性质，值满足最大堆的性质。

        笛卡尔树在多个领域有着广泛的应用，包括但不限于：

        1. 范围查询：由于笛卡尔树的键值满足二叉搜索树的性质，我们可以利用这一特性进行高效的范围查询。例如，查找某个键值范围内的所有元素。

        2. 单调栈/单调队列的替代：在某些场景中，我们可以使用笛卡尔树来替代单调栈或单调队列，以支持更加复杂的操作或查询。

        3. 树形数据结构的构建：笛卡尔树可以用于构建具有特殊性质的树形数据结构，如最大堆性质的二叉搜索树，这在某些算法问题中非常有用。

        4. 可视化与表示：由于笛卡尔树同时结合了搜索树和堆的特点，因此在需要同时展示数据间的层次关系和大小关系时，可以使用笛卡尔树进行可视化表示。

        下面是一个使用C++实现的笛卡尔树构建和中序遍历的完整示例，代码如下。

#include <iostream>
#include <vector>
#include <stack>

struct Node {
    int key;
    int value;
    Node* left;
    Node* right;

    Node(int k, int v) : key(k), value(v), left(nullptr), right(nullptr) {}
};

Node* buildCartesianTree(const std::vector<std::pair<int, int>>& arr) {
    std::stack<Node*> st;
    Node* root = nullptr;

    for (const auto& kv : arr) {
        Node* newNode = new Node(kv.first, kv.second);
        Node* prevNode = nullptr;

        while (!st.empty() && st.top()->value < newNode->value) {
            prevNode = st.top();
            st.pop();
        }

        if (prevNode) {
            newNode->left = prevNode->right;
            prevNode->right = newNode;
        } else {
            root = newNode;
        }

        st.push(newNode);
    }

    return root;
}

void inorderTraversal(Node* node) {
    if (node == nullptr) return;
    inorderTraversal(node->left);
    std::cout << "Key: " << node->key << ", Value: " << node->value << std::endl;
    inorderTraversal(node->right);
}

int main() {
    std::vector<std::pair<int, int>> arr = {{3, 2}, {1, 4}, {4, 1}, {1, 5}, {9, 2}, {2, 6}, {5, 3}, {3, 5}};
    Node* root = buildCartesianTree(arr);

    std::cout << "Inorder Traversal of the Cartesian Tree:" << std::endl;
    inorderTraversal(root);

    // 注意：实际使用时需要释放内存，避免内存泄漏
    // 这里省略了内存释放的代码，以简化示例

    return 0;
}

        

        上面的代码，定义了一个`Node`结构体来表示笛卡尔树的节点，包含了键值、值以及左右子树的指针。`buildCartesianTree`函数接受一个键值-值对序列，并构建对应的笛卡尔树。`inorderTraversal`函数则用于中序遍历笛卡尔树，并打印每个节点的键值和值。在`main`函数中，我们创建一个键值-值对序列，然后调用`buildCartesianTree`构建笛卡尔树，并使用`inorderTraversal`遍历和打印树的节点。

        需要注意的是，实际使用时需要确保在不再需要笛卡尔树时释放其占用的内存，以避免内存泄漏。在上面的示例中，为了简化代码，省略了内存释放的部分。在实际应用中，应该添加适当的代码来释放每个节点所占用的内存。