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

自己：采用统计链表长度的方式找到中点位置，然后遍历链表，将链表分为左链表，中间节点，右链表，然后递归的将链表转化成树的结构

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """

        if not head:
            return None
        if not head.next:
            res_node = TreeNode(head.val)
            return res_node

        res = ListNode(-1)
        res.next = self.sort_list(head)
        return res.next

    def sort_list(self,head):

        if not head:
            return None
   
        count = 0
        p = head
        while p:
            count +=1
            p = p.next

        if count == 1:
            res_node = TreeNode(head.val)
            return res_node

        head_ = ListNode(-1)
        head_.next = head

        mid = count//2
        
        mid_i = 1
        mid_pp = head
        mid_p = head.next
        while mid_i != mid:
            mid_p = mid_p.next
            mid_pp = mid_pp.next     #中点位置的父节点
            mid_i += 1
        mid_pp.next = None
        
        left = self.sort_list(head_.next)
        right = self.sort_list(mid_p.next)

        mid_node = TreeNode(mid_p.val)
        mid_node.left = left
        mid_node.right = right

        return mid_node

大佬1：大佬的方法跟我的差不多，不过大佬选取中点位置的方式是采用指针跳转的方式，一个前面指针每次右移一个，后一个指针每次右移两个，当第二个指针移动到链表结尾的时候，第一个节点就已经指向了链表的中点位置。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """

        if not head: #如果链表没有数据就返回空
            return None

        mid = self.findMiddle(head) #找到中间节点

        node = TreeNode(mid.val)  #中间树节点

        if head == mid: #当只有一个节点的情况
            return node

        node.left = self.sortedListToBST(head)  #循环递归构建左右子节点
        node.right = self.sortedListToBST(mid.next)
        return node

    def findMiddle(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        """

        prevPtr = None #设置中点链表父节点
        slowPtr = head #设置中点链表节点
        fastPtr = head 

        while fastPtr and fastPtr.next:#找到中点
            prevPtr = slowPtr
            slowPtr = slowPtr.next
            fastPtr = fastPtr.next.next

        if prevPtr: #将中点前的链表断开
            prevPtr.next = None

        return slowPtr