LeetCode109-有序链表转换二叉搜索树

昨天去了汉口一屠宰场

观看一家公司如何卸猪

宰猪比较血腥的场景我就没看了

至于我会什么会有如此雅兴去捣鼓这事儿

那是因为最近参加的一个比赛

刚好是要卖猪肉哈哈哈哈

不过去了那家屠宰场观看了他们养猪的地方之后

你会发现你不敢再吃猪肉了

环境是真的很差

猪，浑身比较脏。

也是可怜！

来张还算是比较萌的图片哈哈哈哈哈

---

109-有序链表转换二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

思路：

这一题我将分享两种方法。

方法一：

借鉴第108题将有序数组转换为二叉搜索树的思想，先将有序链表转化为数组，再使用第108题的方法即可快速解决。对第108题不熟悉的读者也可以先看我之前写的文章：

https://blog.csdn.net/weixin_36431280/article/details/90312428

代码如下：

class Solution(object):
    # 本题还可先将链表转化为数组，再用108题方法
     def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """
        if head is None:
            return
        head_list = []
        while head:
            head_list.append(head.val)
            head = head.next
        # 调用和第108题一样的动态规划方法
        def buildBST(nums):
            if len(nums)==0:
                return
            # 取nums列表的中间下标值
            mid_index = len(nums)//2
            pNode = TreeNode(nums[mid_index])
            pNode.left = buildBST(nums[:mid_index])
            pNode.right = buildBST(nums[mid_index+1:])
            return pNode
        return buildBST(head_list)


if __name__ == "__main__":
    nums = [-10, -3, 0, 5, 9]
    head = ListNode(0)
    head_copy = head
    for index in nums:
        head_copy.next = ListNode(index)
        head_copy = head_copy.next
    BTree = Solution().sortedListToBST(head.next)
    print(BTree)

执行效率也是奇快，达到了100%！

 

方法二：快慢指针法

我之前也没接触过这个算法，今天看了一些网上的资料，发现这个算法用来找链表的中间结点很方便，所以就想着学习一下。

算法的思路是：

定义一个快指针fast 一个慢指针slow ，快指针一次移动两个结点，慢指针一次移动一个结点
当fast到达链表的尾部结点时，慢指针也就移动到了链表的中间结点
（同化成一个路程问题，同一段路程，A的速度是B的两倍，他们同时出发，当A走完全程时，B也就刚好走过一半）

中间结点找到了，其他的也就类似了，都是用动态规划的方法解决了。

代码如下：

class Solution(object):
    # 本题采用快慢指针法来获取链表的中间结点
    def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """
        if head is None:
            return
        # 主体还是用动态规划方法
        def buildBST(head, tail):
            if head == tail:
                return
            # 分别定义快慢指针
            slow = head
            fast = head
            # 此处是为了获得链表的中间结点，即slow
            while fast.next is not tail and fast.next.next is not tail:
                slow = slow.next
                fast = fast.next.next
            pNode = TreeNode(slow.val)
            pNode.left = buildBST(head, slow)
            pNode.right = buildBST(slow.next, tail)
            return pNode
        return buildBST(head, None)

执行效率也算不错，达到了70%+！