LeetCode力扣之109. 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

package leetCode;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * Created by lxw, liwei4939@126.com on 2018/3/21.
 */
public class L109_ConvertSortedListToBinarySearchTree {

    public TreeNode sortedListToBST(ListNode head) {

        if (head == null){
            return null;
        }

        if (head.next == null){
            return new TreeNode(head.val);
        }

        ListNode mid = cutAtMid(head);
        TreeNode root = new TreeNode(mid.val);
        root.left = sortedListToBST(head);
        root.right = sortedListToBST(mid.next);

        return root;
    }

    ListNode cutAtMid(ListNode head){
        if (head == null){
            return null;
        }

        ListNode fast = head;
        ListNode slow = head;
        ListNode bslow = null;

        while (fast != null && fast.next != null){
            bslow = slow;
            slow = slow.next;
            fast = fast.next.next;
        }

        bslow.next = null;
        return slow;
    }

    public static void main(String[] args){
        L109_ConvertSortedListToBinarySearchTree tmp = new L109_ConvertSortedListToBinarySearchTree();
        ListNode first = new ListNode(-10);
        ListNode dummy = first;
        int[] arr = new int[]{-3, 0, 5, 9};

        for (int i = 0; i< arr.length; i++){
            ListNode second = new ListNode(arr[i]);
            first.next = second;
            first = second;
        }
        first.next = null;

        TreeNode head = tmp.sortedListToBST(dummy);

        Queue<TreeNode> queue = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        queue.offer(head);

        while (!queue.isEmpty()){
            head = queue.poll();
            res.add(head.val);

            if (head.left != null){
                queue.offer(head.left);
            }
            if (head.right != null){
                queue.offer(head.right);
            }
        }

        System.out.println(res);
    }
}