109. Convert Sorted List to Binary Search Tree**

最新推荐文章于 2020-06-25 08:50:03 发布

珍妮的选择

最新推荐文章于 2020-06-25 08:50:03 发布

阅读量312

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/Eric_1993/article/details/104965933

版权

LeetCode 专栏收录该内容

416 篇文章 4 订阅

订阅专栏

109. Convert Sorted List to Binary Search Tree**

https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/

题目描述

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

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example:

Given the sorted linked list: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

C++ 实现 1

为了产生平衡的 BST, 可以每次找排在中间的节点作为根节点.

下面做法使用了 vector 保存链表中的节点的值.

class Solution {
private:
    TreeNode* convert2BST(const vector<int> &res, int start, int end) {
        if (start > end) return nullptr;
        int mid = start + (end - start) / 2;
        TreeNode *root = new TreeNode(res[mid]);
        root->left = convert2BST(res, start, mid - 1);
        root->right = convert2BST(res, mid + 1, end);
        return root;
    }
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if (!head) return nullptr;
        vector<int> res;
        while (head) {
            res.push_back(head->val);
            head = head->next;
        }
        return convert2BST(res, 0, res.size() - 1);
    }
};

C++ 实现 2

使用快慢指针找到链表的中点. 注意, 下面代码中的 slow 一开始是指向 dummy 的, 如果链表为 1 -> 2 -> NULL, 即只有两个节点的情况, 那么 slow 就会指向 1 而不是 2, 之后使用 slow->next 来得到 2, 即根节点. slow 最终指向根节点前一个节点.

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if (!head)
            return nullptr;

        ListNode *dummy  = new ListNode(0);
        dummy->next = head;
        // slow 最终指向根节点前一个节点
        ListNode *slow = dummy, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        // slow->next 存在, 即根节点存在, 那么可以获得根节点的右边的节点
      	// slow->next->next, 并以它开始构建右子树.
        TreeNode *root = new TreeNode(slow->next->val);
        root->right = sortedListToBST(slow->next->next);
        // 这里不要忘了将前半段链表的结尾设为 NULL.
        slow->next = nullptr;
        root->left = sortedListToBST(dummy->next);
        return root;
    }
};