每日一题算法：2020年8月18日[有序链表转换二叉搜索树]sortedListToBST

2020年8月18日有序链表转换二叉搜索树sortedListToBST

/**
 * Definition for singly-linked list.
 * public 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.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        
    }
}

解题思路：

本题的关键在于要保证二叉树是平衡的，那么我们构建一颗平衡搜索树肯定是有顺序的，而这个顺序应该就是有序链表的中间值的顺序。我们保证每一次取出的都是中值就能构建一颗平衡搜索树。就和所谓的二分搜索法差不多的道理。

具体的做法是使用递归，我们先取出中值，来构建这一个节点，并且把分出的两部分进行递归，生成左右两个子节点。

问题：这里给的链表不是Java工具类中的List，而是自己定义的一个List对象，这样的话我们需要自己对这个List进行处理。

代码实现：

    ArrayList<Integer> array=new ArrayList<>();
    public TreeNode sortedListToBST(ListNode head) {

        //第一步，构建链表
        if (head==null)
            return null;
        else
            array.add(head.val);

        while (head.next!=null){
            head=head.next;
            array.add(head.val);
        }


        //构建链表后，进行递归操作


        return buildTree(0, array.size()-1);
    }

    public TreeNode buildTree(int startIndex,int endIndex){
        
        //如果长度为0，则表示节点为null
        if (endIndex-startIndex<0){
            return null;
        }
        
        TreeNode node=new TreeNode(array.get((startIndex+endIndex)/2));

        
        
        node.left=buildTree(startIndex,(startIndex+endIndex)/2-1);
        node.right=buildTree((startIndex+endIndex)/2+1,endIndex);
        
        return node;
    }