力扣-有序链表转平衡二叉树

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

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 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 Solution {

    public static void main(String[] args) {
        Solution solution = new Solution();
        ListNode nodes = solution.initData();
        TreeNode root = solution.sortedListToBST(nodes);
        System.out.println(root);
    }

    public TreeNode sortedListToBST(ListNode head) {
        TreeNode from = null;
        //有序链表转二叉树
        while (head != null) {
            TreeNode treeNode = new TreeNode(head.val);
            if (from != null) {
                treeNode.left = from;
            }
            from = treeNode;
            head = head.next;
        }
        //递归转换为平衡二叉树
        return divider(from, true);
    }

    //递归往下遍历节点
    private TreeNode divider(TreeNode nodes, boolean isLeft) {
        if (nodes == null) {
            return null;
        }
        if (nodes.val == -5) {
            System.out.println("xx");
        }
        int leftLevel = 0;
        int rightLevel = 0;
        TreeNode rootNode = nodes;
        TreeNode leftNode = nodes.left;
        TreeNode rightNode = nodes.right;

        if (isLeft) {
            while (leftNode != null) {
                leftLevel++;
                //需要进行节点转换
                leftNode = leftNode.left;
                if (leftLevel - rightLevel >= 2) {
                    if (rootNode.left != null) {
                        rootNode.left.right = rootNode;
                    }
                    rootNode = rootNode.left;
                    rootNode.right.left = null;
                    leftLevel--;
                    rightLevel++;
                }
            }
        } else {
            while (rightNode != null) {
                rightLevel++;
                //需要进行节点转换
                rightNode = rightNode.right;
                if (rightLevel - leftLevel >= 2) {
                    if (rootNode.right != null) {
                        rootNode.right.left = rootNode;
                    }
                    rootNode = rootNode.right;
                    rootNode.left.right = null;
                    rightLevel--;
                    leftLevel++;
                }
            }
        }

        rootNode.left = divider(rootNode.left, true);
        rootNode.right = divider(rootNode.right, false);
        return rootNode;
    }
    
    //测试数据
    private ListNode initData() {
        ListNode node19 = new ListNode(-9);
        ListNode node18 = new ListNode(-8);
        ListNode node17 = new ListNode(-7);
        ListNode node16 = new ListNode(-6);
        ListNode node15 = new ListNode(-5);
        ListNode node14 = new ListNode(-4);
        ListNode node13 = new ListNode(-3);
        ListNode node0 = new ListNode(0);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        ListNode node7 = new ListNode(7);
        ListNode node8 = new ListNode(8);
        ListNode node9 = new ListNode(9);

        node19.next = node18;
        node18.next = node17;
        node17.next = node16;
        node16.next = node15;
        node15.next = node14;
        node14.next = node13;
        node13.next = node0;
        node0.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        node7.next = node8;
        node8.next = node9;
        return node19;
    }

}