二叉搜索树与双向链表

最新推荐文章于 2022-04-21 11:07:58 发布

三体问题

最新推荐文章于 2022-04-21 11:07:58 发布

阅读量127

点赞数 1

CC 4.0 BY-SA版权

分类专栏：算法题

本文链接：https://blog.youkuaiyun.com/q943520218/article/details/99764592

算法题专栏收录该内容

34 篇文章

订阅专栏

本文介绍了如何将二叉搜索树转换成一个排序的双向链表，通过中序遍历实现，讨论了不同优化策略，包括使用指针记录前一个节点以及非递归实现以节省空间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

一、解题

二叉搜索树，顾名思义，就是根节点左子树都比根节点元素小，右子树的节点都比根节点大的树，搜索的速度取决于树的高度，如果树的构造接近完全二叉树，那么搜索效率为lgn，如果高度接近n，那么搜索效率就为n，n为节点数。

解题思路，二叉搜索树的中序遍历结果就是一个顺序数组，所以只有中序遍历就可以了。

#pragma once

#include <vector>

namespace search_tree
{
    struct TreeNode {
        int val;
        struct TreeNode *left;
        struct TreeNode *right;
        TreeNode(int x) :
            val(x), left(nullptr), right(nullptr) {
        }
    };
    class Solution {
    public:
        TreeNode* Convert(TreeNode* pRootOfTree)
        {
            if (pRootOfTree == nullptr)
            {
                return nullptr;
            }
            std::vector<TreeNode *> vec;
            foreach(pRootOfTree, vec);

            auto pNode = vec[0];
            pNode->left = nullptr;
            for (int i = 1; i < vec.size(); i++)
            {
                pNode->right = vec[i];

                vec[i]->left = pNode;
                vec[i]->right = nullptr;
                pNode = vec[i];
            }

            return vec[0];
        }

        void foreach(TreeNode* pRootOfTree, std::vector<TreeNode *> &vec)
        {
            if (pRootOfTree == nullptr)
            {
                return;
            }
            foreach(pRootOfTree->left, vec);

            vec.push_back(pRootOfTree);

            foreach(pRootOfTree->right, vec);
        }
    };
}

二、优化

我们引入了一个vector数组来纪录，遍历的节点指针，其实可以不需要，只要一个pro指针就够了，用pro来纪录上一个遍历的节点就可以了

        TreeNode* Convert(TreeNode* pRootOfTree)
        {
            if (pRootOfTree == nullptr)
            {
                return nullptr;
            }
  
            TreeNode *pro = nullptr;
            foreach(pRootOfTree, pro);

            return _first;
        }

        void foreach(TreeNode* pRootOfTree, std::vector<TreeNode *> &vec)
        {
            if (pRootOfTree == nullptr)
            {
                return;
            }
            foreach(pRootOfTree->left, vec);

            vec.push_back(pRootOfTree);

            foreach(pRootOfTree->right, vec);
        }

        void foreach(TreeNode* pRootOfTree, TreeNode *&pro)
        {
            if (pRootOfTree == nullptr)
            {
                return;
            }
            foreach(pRootOfTree->left, pro);

            pRootOfTree->left = pro;
            if (pro)
                pro->right = pRootOfTree;

            if (first)
            {
                _first = pRootOfTree;
                first = false;
            }

            pro = pRootOfTree;

            foreach(pRootOfTree->right, pro);
        }

        TreeNode *_first = nullptr; 
        bool first = true;

三、再优化

我们知道，递归占用的空间其实比vector占用的空间大的多，所有实际上，vector消去只在时间上有优势，在空间上的优化微乎其微，所以非递归的实现才是最优化的。

实现暂无