LeetCode - Convert Sorted List to Binary Search Tree

最新推荐文章于 2021-11-02 12:48:41 发布

原创最新推荐文章于 2021-11-02 12:48:41 发布 · 326 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode

算法专栏收录该内容

131 篇文章

订阅专栏

本文介绍了一种将有序链表转换为高度平衡二叉搜索树的方法。通过两种不同的实现方式，一种先将链表元素存储到数组中再构建树，另一种直接在链表上操作，达到O(N)的时间复杂度。

本来以为题目比较简单，就是每次以中间元素作为父节点递归简历左右子树。

优化：先把链表元素存入vector中，便于快速存取中间元素。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *_build(vector<int> &v, int start, int end){
		if(start>end)
			return NULL;
		if(start == end)
			return new TreeNode(v[start]);
		int mid = (start+end+1)/2;
		TreeNode *node = new TreeNode(v[mid]);
		node->left = _build(v,start,mid-1);
		node->right = _build(v,mid+1,end);
		return node;
	}

	TreeNode *sortedListToBST(ListNode *head) {
		if(head==NULL)
			return NULL;
		vector<int> v;
		while(head){
			v.push_back(head->val);
			head = head->next;
		}
		int start = 0;
		int end = v.size()-1;
		TreeNode *root = _build(v,start,end);
		return root;
	}
};

后来发现，还有一题是给你List Array，那跟这题有什么区别？所以肯定还是用List来做。如果遍历list获得中间元素的话，总的时间复杂度则需要O(NlogN)。

Leetcode官网给出了O(N)的解法，非常精妙，从底向上建树，只需要顺序遍历List一次即可。而且代码非常简洁，只是不太容易想得到。注意_build函数的ListNode参数为引用。

class Solution {
public:
    TreeNode *_build(ListNode *&head, int start, int end){
		if(start > end)
			return NULL;
		int mid = start + (end-start)/2;
		TreeNode *left = _build(head,start,mid-1);
		TreeNode *father  = new TreeNode(head->val);
		father->left = left;
		head = head->next;
		father->right = _build(head,mid+1,end);
		return father;
	}

	TreeNode *sortedListToBST(ListNode *head) {
		ListNode *tmp = head;
		int len=0;
		while(tmp){
			++len;
			tmp = tmp->next;
		}
		TreeNode *root = _build(head,0,len-1);
		return root;
	}

};