LeetCode 108, 109. Convert Sorted Array/List to Binary Search Tree-优快云博客

本文介绍如何将升序数组和链表转换为高度平衡的二叉搜索树(BST)。利用递归方法选取中间元素作为根节点，并进一步划分左右子树。针对链表，采用快慢指针技巧定位中点，实现高效转换。

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

1. 题目描述

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

2. 解题思路

拿到这种题目，第一反应就是使用递归处理，提取中间的元素，拆成左右两个子问题进行处理。
对于数组很容易得到他的中间元素，对于链表，我们可以使用快慢指针来提取他的中间项。

3. code

虽然，感觉 109 的两个解法应该都是可以的，而且leetcode 上也通过了，不过牛课上对第一种解法不认可，感觉没道理，因为第一种解法出来的结果也是符合要求的，没办法，改成了第二种解法，结果发现，效率提高了。。。。

// 108
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return _sortedArrayToBST(nums, 0, nums.size());
    }

private:
    TreeNode * _sortedArrayToBST(vector<int> & nums, int start, int stop){
        if (start >= stop)
            return nullptr;

        //int mid = start + (stop - start) >> 1;
        int mid = start + ((stop - start) >> 1);
        TreeNode * root = new TreeNode(nums[mid]);
        TreeNode * left = _sortedArrayToBST(nums, start, mid);
        TreeNode * right = _sortedArrayToBST(nums, mid + 1, stop);
        root->left = left;
        root->right = right;
        return root;
    }
};

// 109 demo1
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if (head == nullptr)
            return nullptr;

        ListNode myhead(0), *p1(nullptr), *p2(nullptr), *pre(nullptr);
        myhead.next = head;
        p1 = p2 = pre = &myhead;
        while (p1 && p1->next){
            p1 = p1->next->next;
            pre = p2;
            p2 = p2->next;
        }

        // ps: 注意链表分割， 特殊情况， p2 指向第一个指针时候
        pre->next = nullptr;
        if (head == p2)
            head = nullptr;
        TreeNode * root = new TreeNode(p2->val);
        TreeNode * left = sortedListToBST(head);
        TreeNode * right = sortedListToBST(p2->next);
        root->left = left;
        root->right = right;
        return root;
    }
};

// demo 2
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if (head == nullptr)
            return nullptr;

        ListNode *p1(head), *p2(head), *pre(head);
        while (p1 && p1->next){
            p1 = p1->next->next;
            pre = p2;
            p2 = p2->next;
        }

        // ps: 注意链表分割， 特殊情况， p2 指向第一个指针时候
        pre->next = nullptr;
        if (head == p2)
            head = nullptr;
        TreeNode * root = new TreeNode(p2->val);
        TreeNode * left = sortedListToBST(head);
        TreeNode * right = sortedListToBST(p2->next);
        root->left = left;
        root->right = right;
        return root;
    }
};

4. 大神code

这个解法有个好处，不用修改原始链表了。。。。

// 109
class Solution {
public:
    TreeNode *sortedListToBST(ListNode *head)
    {
        return sortedListToBST( head, NULL );
    }

private:
    TreeNode *sortedListToBST(ListNode *head, ListNode *tail)
    {
        if( head == tail )
            return NULL;
        if( head->next == tail )    // 
        {   
            TreeNode *root = new TreeNode( head->val );
            return root;
        }
        ListNode *mid = head, *temp = head;
        while( temp != tail && temp->next != tail )    // 寻找中间节点
        {
            mid = mid->next;
            temp = temp->next->next;
        }
        TreeNode *root = new TreeNode( mid->val );
        root->left = sortedListToBST( head, mid );
        root->right = sortedListToBST( mid->next, tail );
        return root;
    }
};