Convert Sorted List to Binary Search Tree

最新推荐文章于 2020-08-18 08:24:28 发布

SUN_DRAGON

最新推荐文章于 2020-08-18 08:24:28 发布

阅读量679

点赞数

CC 4.0 BY-SA版权

分类专栏： C++

本文链接：https://blog.youkuaiyun.com/SUN_DRAGON/article/details/9410521

C++ 专栏收录该内容

27 篇文章

订阅专栏

本文介绍了一种将有序链表转换为高度平衡二叉搜索树的有效方法。通过在链表中间位置选取节点作为根节点，并递归地构造左右子树，实现了O(n log n)的时间复杂度。

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

Convert Sorted List to Binary Search TreeOct 3 '123397 / 9589

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

刚开始想用课本上的构造平衡二叉树的方法，当不满足时，回溯，旋转，结果在运行大的数据时，超时。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void insertBST(TreeNode* &root, int val)
    {
        if(root == NULL)
        {
            root = new TreeNode(val);
        }
        else if(val > root->val)
        {
            insertBST(root->right, val);
        }
        else if(val < root->val)
        {
            insertBST(root->left, val);
        }
    }
    void turnLeft(TreeNode* &root)
    {
        
        TreeNode* tempCR = root->right->left;
        root->right->left = root;        
        root = root->right;
        root->left->right = tempCR;
    }
    int adjust(TreeNode* &root)
    {
        if(root)
        {
            int hl = adjust(root->left);
            int hr = adjust(root->right);
            if(hr > hl + 1)
            {
                turnLeft(root);
                return max(hl, hr);
            }
            return max(hl, hr)+1;
        }
        return 0;
    }
    TreeNode *sortedListToBST(ListNode *head) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(head == NULL)
            return NULL;
        TreeNode* root = NULL;
        while(head)
        {
            insertBST(root, head->val);
            adjust(root);
            head = head->next;
        }
        return root;
    }
};

后来，想直接在中间节点分开，递归构造。复杂度应该为nlogn

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(ListNode* head, int len)
    {
        if(head && len > 0)
        {
            int l = len/2;
            ListNode* p = head;
            int count = 0;
            while(p && count < l)
            {
                count ++;
                p = p->next;
            }
            TreeNode* tre = new TreeNode(p->val);
            TreeNode* lc = buildTree(head, count);
            TreeNode* lr = buildTree(p->next, len - count -1);
            tre->left = lc;
            tre->right = lr;
            return tre;
        }
        return NULL;
    }
    TreeNode *sortedListToBST(ListNode *head) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int len = 0;
        ListNode* p = head;
        while(p)
        {
            len ++;
            p = p ->next;
        }
        return buildTree(head,len);
    }
};