LeetCode刷题日记 2020/08/18

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

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

示例:

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

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

0
      / \
    -3   9
    /   /
  -10  5

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree

思路：

按照升序排列的单链表，我们只需要找到他的中间结点，让他成为树的根节点，中间结点前面的就是根节点左子树的所有节点，中间节点后面的就是根节点右子树的所有节点，然后使用递归的方式再分别对左右子树进行相同的操作

代码如下

public class Test01 {
    public static void main(String[] args) {
        ListNode head = new ListNode(-10);
        ListNode listNode1 = new ListNode(-3);
        ListNode listNode2 = new ListNode(0);
        ListNode listNode3 = new ListNode(5);
        ListNode listNode4 = new ListNode(9);
 
        head.next = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
 
        TreeNode1 treeNode1 = Solution.sortedListToBST(head);
 
        System.out.println(treeNode1);
    }
}
 
//Definition for singly-linked list.
class ListNode {
    int val;
    ListNode next;
 
    ListNode() {
    }
 
    ListNode(int val) {
        this.val = val;
    }
 
    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
 
// * Definition for a binary tree node.
class TreeNode1 {
    int val;
    TreeNode1 left;
    TreeNode1 right;
 
    TreeNode1() {
    }
 
    TreeNode1(int val) {
        this.val = val;
    }
 
    TreeNode1(int val, TreeNode1 left, TreeNode1 right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
 
class Solution {
    public static TreeNode1 sortedListToBST(ListNode head) {
        //边界条件的判断
        if (head == null)
            return null;
        if (head.next == null)
            return new TreeNode1(head.val);
        //这里通过快慢指针找到链表的中间结点slow，pre就是中间
        //结点slow的前一个结点
        ListNode slow = head, fast = head, pre = null;
        while (fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        //链表断开为两部分，一部分是node的左子节点，一部分是node
        //的右子节点
        pre.next = null;
        //node就是当前节点
        TreeNode1 node = new TreeNode1(slow.val);
        //从head节点到pre节点是node左子树的节点
        node.left = sortedListToBST(head);
        //从slow.next到链表的末尾是node的右子树的结点
        node.right = sortedListToBST(slow.next);
        return node;
    }
}