顺序存储构建的二叉树转换成链式存储二叉树

二叉树结点的创建

class TreeNode
{
    
    
public:
    int value;              // 所对应的值
    TreeNode *left, *right; // 下一个结点的地址
    TreeNode(int val)
    {
    
    
        value = val;
        left = nullptr;
        right = nullptr;
    }
    ~TreeNode()
    {
    
    
        delete right;
        delete left;
    }
};

顺序存储构建的二叉树转换成链式存储二叉树

根据二叉树的左子树和左子树是根节点序号的关系：

• 根节点序号：i
• 左子树根节点序号：i*2+1
• 右子树根节点序号：i*2+2

以上关系在以顺序存储方式的数组中。

步骤：

• 创建存储二叉树结点的数组和根节点
• 初始化二叉树结点数组
• 将形参的数值数组根据根节点和左右孩子序号的关系来构建转换成链式存储二叉树

class BinaryTree
{
    
    
public:
    // 将顺序存储的二叉树转换成链式存储的二叉树
    static TreeNode *construct_BinaryTree(vector<int> nums)
    {
    
    
        // 创建存储二叉树结点的数组和根节点
        TreeNode *root = nullptr;
        vector<TreeNode *> vecTree(nums.size(), nullptr);

        // 初始化二叉树数组
        for (int i = 0; i < nums.size(); i++)
        {
    
    
            // 如果数组元素值不为-1则设置结点值
            TreeNode *node = nullptr;
            if (nums[i] != -1)
            {
    
    
                node = new TreeNode(nums[i]);
            }
            vecTree[i] = node;

            // 如果是根节点则更新root的值
            if (i == 0)
            {
    
    
                root = node;
                /* code */
            }
        }

        // 将存储二叉树子结点的数组转换成链式存储，
        for (int i = 0; i * 2 + 1 < vecTree.size(); i++)
        {
    
    
            if (vecTree[i * 2 + 1] != nullptr)
            {
    
    
                vecTree[i]->left = vecTree[i * 2 + 1];
                if (i * 2 + 2 < vecTree.size())
                {
    
    
                    /* code */
                    vecTree[i]->right = vecTree[i * 2 + 2];
                }
            }
        }

        // 返回链式存储的二叉树根节点
        return root;
    }

    // 前序遍历
    static void PreTaverse(TreeNode *node)
    {
    
    
        if (node == nullptr)
        {
    
    
            return;
        }
        // 输出节点的值
        cout << node->value << "\t";
        // 访问左子树
        PreTaverse(node->left);
        // 访问右子树
        PreTaverse(node->right);
    }
    // 中序遍历
    static void MidTaverse(TreeNode *node)
    {
    
    
        if (node == nullptr)
        {
    
    
            return;
        }

        // 访问左子树
        MidTaverse(node->left);
        // 输出节点的值
        cout << node->value << "\t";
        // 访问右子树
        MidTaverse(node->right);
    }
    // 后序遍历
    static void BackTaverse(TreeNode *node)
    {
    
    
        if (node == nullptr)
        {
    
    
            return;
        }

        // 访问左子树
        BackTaverse(node->left);

        // 访问右子树
        BackTaverse(node->right);

        // 输出节点的值
        cout << node->value << "\t";
    }
};

遍历输出测试

使用二叉树中的遍历方法来检验转换后的链式存储二叉树

int main(int argc, char const *argv[])
{
    
    
    // 二叉树的数值数组
    vector<int> nums = {
    
    1, 2, 3, 4, 5, 6, 7};

    TreeNode *root = BinaryTree::construct_BinaryTree(nums);
    // 遍历输出
    cout << "先序遍历：";
    BinaryTree::PreTaverse(root);
    cout << endl;

    cout << "中序遍历：";
    BinaryTree::MidTaverse(root);
    cout << endl;

    cout << "后序遍历：";
    BinaryTree::BackTaverse(root);
    cout << endl;

    return 0;
}

输出结果：