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.

题意：

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

思路一：

将有序链表存在一个数组里。根据每次访问中间节点当做根节点，递归调用左右子树节点。

代码：30ms

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return NULL;
        
        vector<int> tmp;
        while(head){  //将链表转换为数组
            tmp.push_back(head->val);
            head = head->next;
        }
        return sortedArrayTree(tmp, 0, tmp.size()-1);
    }
    
    TreeNode *sortedArrayTree(vector<int> &arr, int start, int end){
        if(start > end) return NULL;
        
        TreeNode *root = new TreeNode(arr[(start+end)/2]); //取数组中间元素作为根节点
        
        root->left = sortedArrayTree(arr, start, (start+end)/2-1);
        root->right = sortedArrayTree(arr, (start+end)/2+1, end);
        return root;
    }
};

思路二：

定义两个分别为一快一慢的节点变量，慢节点每次向前一步，快节点每次向前两步，当快节点到达末尾时，慢节点到链表中间位置，慢节点值即为二叉搜索树的根节点值，之后依次递归左右子树。

代码：1ms

/**
 * 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; }
 * }
 */
public class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return rec(head, null);
    }
    
    public TreeNode rec(ListNode start, ListNode end){
        if(start==end) return null;
        
        ListNode p = start, q = start;
        while(q!=end && q.next!=end){  //找到链表中间值
            p = p.next;
            q = q.next.next;
        }
        
        TreeNode root = new TreeNode(p.val);  //链表中间值作为根节点
        root.left = rec(start, p);
        root.right = rec(p.next, end);
        
        return root;
    }
}

思路三：

先求出链表长度，将链表长度作为参数传递进递归函数，每次寻找链表中点时，只需要新定义的指针向前移动一般链表长度即可，将找到的节点值作为根源上节点值，之后递归调用左右子树。

代码：28ms

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        int n = 0;
        ListNode *p = head;
        while(p!=NULL){  //得到链表长度
            n++;
            p = p->next;
        }
        return sortedListToBST(head, n);
    }
    
    TreeNode *sortedListToBST(ListNode *head, int n){
        if(head==NULL || n==0) return NULL;
        
        ListNode *p = head;
        for(int i=1; i<(n+1)/2; ++i){  //每次找到传入长度的中间值
            p = p->next;
        }
        TreeNode *root = new TreeNode(p->val);  //将中间值作为根节点
        root->left = sortedListToBST(head, (n+1)/2-1);
        root->right = sortedListToBST(p->next, n-(n+1)/2);
        return root;
    }
};

思路四：

以上三种方法都是自顶向下生成的二叉树，本方法采用自底向上的方式生成二叉树，迭代递归时，根据链表顺序依次将链表值填入二叉搜索树中。

代码：1ms

/**
 * 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; }
 * }
 */
public class Solution {
    
    static ListNode currentHead = null;
    
    public TreeNode sortedListToBST(ListNode head) {
        if(head==null) return null;
        currentHead = head;
        int len = 0;
        while(head!=null){  //获取链表长度
            len++;
            head = head.next;
        }
        return sortedListToBST(0, len-1);
    }
    
    public TreeNode sortedListToBST(int start, int end){
        if(start>end) return null;
        
        int mid = start + (end-start)/2; 
        TreeNode left = sortedListToBST(start, mid-1); //生成左子树
        TreeNode root = new TreeNode(currentHead.val); 
        root.left = left;
        currentHead = currentHead.next;  //链表后移
        root.right = sortedListToBST(mid+1, end);   //生成右子树
        return root;
    }
}