LeetCode-Convert Sorted List to Binary Search Tree

作者：disappearedgod

文章出处：http://blog.csdn.net/disappearedgod/article/details/24153001

时间：2014-4-22

题目

Convert Sorted List to Binary Search Tree

  Total Accepted: 9559  Total Submissions: 35965 My Submissions

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

解法

未完成

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    static ListNode h;
    public TreeNode sortedListToBST(ListNode head) {
        if(head==null)
            return null;
        TreeNode tree = new TreeNode(head.val);    
        if(head.next==null)
            return tree;
        h = head;
       // tree=build(head.next,tree);
        
        ListNode p =head;
        TreeNode pt = tree;
        //tree = build(head,tree);
        for(;head!=null;head=head.next){
            tree=instert(tree,head.val);
        }
        return tree;
    }
    private TreeNode instert(TreeNode tree, int key){
        if(tree == null){
            tree = new TreeNode(key);
        }else{
            int cmp = key-tree.val;
            if(cmp<0){
                tree.left=insert(tree.left,key);
                if(height(tree.left)-height(tree.right)==2){
                    if(key-tree.left.val<0)
                        tree = leftLeftRotation(tree);
                    else
                        tree = leftRightRotation(tree);
                }
            }else if(cmp>0){
                tree.right=insert(tree.right,key);
                if(height(tree.left)-height(tree.right)==-2){
                    if(key-tree.right.val<0)
                        tree = rightLeftRotation(tree);
                    else
                        tree = rightRightRotation(tree);
                }
            }
        }
        return tree;
        
    }
    
    private TreeNode leftLeftRotation(TreeNode t){
        TreeNode t_left;
        
        t_left = t.left;
        t.left = t_left.right;
        t_left.right=t;
        
        
        return t_left;
    }
    private TreeNode rightRightRotation(TreeNode t){
        TreeNode t_right;
        
        t_right = t.right;
        t.right= t_right.left;
        t_right.left = t;
        return t_right;
    }
    private TreeNode leftRightRotation(TreeNode t){
        t.left = rightRightRotation(t.left);
        
        return leftLeftRotation(t);
    }
    private TreeNode rightLeftRotation(TreeNode t){
        t.right = leftLeftRotation(t.right);
        
        return rightRightRotation(t.right);
    }
    private TreeNode build(ListNode head,TreeNode t){
        if(head.next==null)
          return t;
        ListNode p =head;
        TreeNode pt = t;
        while(p.next!=null){
            pt.right = new TreeNode(p.next.val);
            pt = pt.right;
            p = p.next;
        }
        //pt.right = new TreeNode(height(t.left));
       // pt = pt.right;
        //pt.right = new TreeNode(height(t.right));
        //pt = pt.right;
        return t;
    }
    private boolean isBalance(TreeNode root){
        int diff = height(root.right)-height(root.left);
        return (diff>2||diff<-2)?true:false;
    }
    private int height(TreeNode root){
        if(root ==null)
            return 0;
        int height = 1;
        if(root.left==null && root.right == null)
            return 1;
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if(leftHeight > rightHeight)
            height = leftHeight + 1;
        if(rightHeight < leftHeight)
            height = rightHeight + 1;
        return height;
    }
    private TreeNode sortedListToBST1(ListNode head){
         if(head==null)
            return null;
        int len = getlen(head);
        return sortedListToBST(head,0,len-1);
    }
    private int getlen(ListNode head){
        int len = 0;
        for(ListNode p = head;p!=null;len++,p=p.next);
        return len;
    }
    public TreeNode sortedListToBST(ListNode list,int start, int end){
        if(start>end)
          return null;
        int mid = start + (end - start) / 2;// same as (start+end)/2, avoids overflow
        TreeNode left = sortedListToBST(list,start, mid-1);

        TreeNode treenode = new TreeNode(list.val);
        h=h.next;
       
        TreeNode right = sortedListToBST(list,mid+1,end);
        treenode.left = left;
        treenode.right =right;
        return treenode;
    }
    
}

返回

LeetCode Solution(持续更新，java>c++)