给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定的有序链表: [-10, -3, 0, 5, 9],
一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:
0
/ \
-3 9
/ /
-10 5
解题思路:
我想到的是每一次分治,然后分支的中间节点是根节点,左右分别是左右子树。所以重点就是要得到链表的中间节点
1. 我们可以从顶向下,即直接遍历整个链表,用数组存起来,这样就知道每一个中间节点
2. 可以自底向上,当我们知道链表的长度之后,我们可以根据长度来递归,根据递归的特性,首先肯定是得到左子树的连接,然后才是右子树。
我的code:由于存储整个数组,空间复杂度在O(n),由于需要遍历整个链表,时间复杂度为O(n)
class Solution {
public:
TreeNode* backthrough(vector<ListNode*> &lnode,int l,int r)
{
if(l==r)
{
TreeNode* tnode = new TreeNode(lnode[l]->val);
return tnode;
}
int m=l+(r-l+1)/2;
TreeNode* left=NULL;
TreeNode* right=NULL;
if(m-1>=l)
left=backthrough(lnode,l,m-1);
if(m+1<=r)
right=backthrough(lnode,m+1,r);
TreeNode* mnode = new TreeNode(lnode[m]->val);
mnode->left=left;
mnode->right=right;
return mnode;
};
TreeNode* sortedListToBST(ListNode* head) {
if(!head)
return NULL;
vector<ListNode*> lnode;
while(head)
{
lnode.push_back(head);
head=head->next;
}
return backthrough(lnode,0,lnode.size()-1);
}
};
直接遍历得到长度:时间复杂度就是遍历整个链表O(n),空间复杂度为递归的树的高度O(logn):
var h *ListNode
func sortedListToBST(head *ListNode) *TreeNode {
if head == nil {
return nil
}
length := 0
h = head
for head != nil {
length++
head = head.Next
}
return buildBST(0, length-1)
}
func buildBST(start, end int) *TreeNode {
if start > end {
return nil
}
mid := (start + end) >> 1
left := buildBST(start, mid-1)
root := &TreeNode{Val: h.Val}
h = h.Next
root.Left = left
root.Right = buildBST(mid+1, end)
return root
}