Leetcode 109. Convert Sorted List to Binary Search Tree

原创于 2021-01-12 00:53:34 发布 · 170 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#bst #recursion #dfs

Leetcode 专栏收录该内容

278 篇文章

订阅专栏

博客介绍了将链表转换为二叉搜索树的三种方法。方法一是先将链表转为数组再处理，时间和空间复杂度均为n；方法二采用递归，时间复杂度nlogn，空间复杂度logn，需处理节点衔接；方法三是中序模拟，模拟中序遍历，时间复杂度n，空间复杂度logn。

在这里插入图片描述
方法1： 和108题一样，这题的input是一个linkedlist，所以我们先把这个list转换成array，然后和108题一样做。时间复杂n，空间复杂n。

/**
 * 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) {
        if(head == null) return null;
        List<Integer> list = new ArrayList<>();
        while(head!= null){
            list.add(head.val);
            head = head.next;
        }
        return helper(list);
    }
    
    public TreeNode helper(List list){
        if(list.size() == 0) return null;
        TreeNode mid = new TreeNode((int)list.get(list.size()/2));
        mid.left = helper(list.subList(0,list.size()/2));
        mid.right = helper(list.subList(list.size()/2 + 1, list.size()));
        return mid;
    }
    
}

方法2: recursion。时间复杂nlogn，空间复杂logn。这个方法涉及到node衔接问题，所以需要keep一个prev node。

/**
 * 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) {
        if(head == null) return null;
        if(head.next == null) return new TreeNode(head.val);
        int size = findSize(head)/2;
        TreeNode root = new TreeNode();
        ListNode c = head;
        ListNode prev = null;
        while(size > 0){
            root.val = c.val;
            prev = c;
            c = c.next;
            size--;
        }
        prev.next = null;
        root.val = c.val;
        root.left = sortedListToBST(head);
        root.right = sortedListToBST(c.next);
        return root;
    }
    
    private int findSize(ListNode head){
        ListNode ptr = head;
        int c = 0;
        while(ptr != null){
            ptr = ptr.next;
            c++;
        }
        return c;
    }
}

方法3: Inorder Simulation。这是lc官方解答3。它是模拟了inorder traversal。这个方法的精髓就在于head的变化，这一点上确实是实实在在模拟了inorder traversal。不是特别好理解的方法，但是非常巧妙，复盘的时候可以再看看。时间复杂n，空间复杂logn。

/**
 * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int
 * x) { val = x; } }
 */
/**
 * Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode
 * right; TreeNode(int x) { val = x; } }
 */
class Solution {

  private ListNode head;

  private int findSize(ListNode head) {
    ListNode ptr = head;
    int c = 0;
    while (ptr != null) {
      ptr = ptr.next;  
      c += 1;
    }
    return c;
  }

  private TreeNode convertListToBST(int l, int r) {
    // Invalid case
    if (l > r) {
      return null;
    }

    int mid = (l + r) / 2;

    // First step of simulated inorder traversal. Recursively form
    // the left half
    TreeNode left = this.convertListToBST(l, mid - 1);

    // Once left half is traversed, process the current node
    TreeNode node = new TreeNode(this.head.val);
    node.left = left;

    // Maintain the invariance mentioned in the algorithm
    this.head = this.head.next;

    // Recurse on the right hand side and form BST out of them
    node.right = this.convertListToBST(mid + 1, r);
    return node;
  }

  public TreeNode sortedListToBST(ListNode head) {
    // Get the size of the linked list first
    int size = this.findSize(head);

    this.head = head;

    // Form the BST now that we know the size
    return convertListToBST(0, size - 1);
  }
}

总结：