链表14

最新推荐文章于 2024-07-20 08:41:47 发布

米缸没米了

最新推荐文章于 2024-07-20 08:41:47 发布

阅读量96

点赞数

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

本文链接：https://blog.csdn.net/qq_31307013/article/details/80237682

版权

LeetCode 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

1、题目：

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

2、解答：平衡二叉树，问题关键是找到根结点，由于链表是升序的，所以找到中间结点，然后递归

3、C++代码

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;
    }
    
};

python代码

class Solution:
    def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """
        if not head:
            return None
        
        slow = head
        fast = head
        prev = None
        
        while fast and fast.next:
            prev = slow
            slow = slow.next
            fast = fast.next.next
            
        if prev:
            prev.next = None
        else:
            head = None
        
        root = TreeNode(slow.val)
        root.right = self.sortedListToBST(slow.next)
        root.left = self.sortedListToBST(head)
        
        return root