109有序链表转换二叉搜索树（递归）

1、题目描述

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

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

2、示例

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

3、题解

基本思想：递归，找到链表中间节点p，以p->next节点为根节点，分成左右子树，不断递归此过程

• 计算有效链表长度len，找到链表中间节点p，以p->next节点为根节点，分成左右子树
• 中间节点右部分递归调用，构建成二叉搜索树的右子树
• 中间节点左部分递归调用，构建成二叉搜索树的左子树
• 递归终止条件为链表长度为0或1

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
void Init_ListNode(ListNode* head, vector<int> vec)
{
	if (vec.size() == 0)
	{
		head = NULL;
		return;
	}
	ListNode* p;
	p = head;
	p->val = vec[0];
	for (int i = 1; i < vec.size(); i++)
	{
		ListNode* q = new ListNode(vec[i]);
		p->next = q;
		p = p->next;
	}
	p->next = NULL;
}
void PreOrderTraverse(TreeNode* T)
{
	if (T == NULL)
		return;
	cout << T->val << " ";
	PreOrderTraverse(T->left);
	PreOrderTraverse(T->right);
}
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
		//简化版：递归，以中间值将链表分割成两部分，左半部分为root的左子树，右半部分为root的右子树
        TreeNode* root=nullptr;
        ListNode* start=new ListNode(0,head);
        Recursion(start,root);
        return root;
    }
    void Recursion(ListNode* start,TreeNode* &root)
    {
        if(start->next==nullptr)
            return;
        ListNode* p=start->next;
        int len=0;
        while(p)
        {
            len++;
            p=p->next;
        }
        p=start;
        for(int i=0;i<len/2;i++)
            p=p->next;
        root=new TreeNode(p->next->val);
        Recursion(p->next,root->right);
        p->next=nullptr;
        Recursion(start,root->left);
    }
};
class Solution1 {
public:
	TreeNode* sortedListToBST(ListNode* head) {
		//基本思想：递归，找到链表中间节点p，以p->next节点为根节点，分成左右子树，不断递归此过程
		if (head == NULL)
			return NULL;
		TreeNode* root = NULL;
		//多加一个start无效头节点，方便处理
		ListNode *start = new ListNode(0);
		start->next = head;
		Recursion(start, &root);
		return root;
	}
	void Recursion(ListNode* head, TreeNode** root)
	{
		//递归终止条件为链表长度为0
		if (head->next == NULL)
			return;
		int len = 0;
		//计算有效链表长度len
		ListNode* p = head->next;
		while (p != NULL)
		{
			len++;
			p = p->next;
		}
		//找到链表中间节点p，以p->next节点为根节点，分成左右子树
		p = head;
		for (int i = 0; i < len/2; i++)
			p = p->next;
		//p->next节点为根节点
		(*root) = new TreeNode(p->next->val);
		//递归终止条件为链表长度为1
		if (len == 1)
			return;
		//中间节点右部分递归调用，构建成二叉搜索树的右子树
		Recursion(p->next, &(*root)->right);
		//中间节点左部分递归调用，构建成二叉搜索树的左子树
		p->next = NULL;
		Recursion(head, &(*root)->left);	
	}
};

int main()
{
	Solution solute;
	ListNode* head = new ListNode(0);
	vector<int> vec = { 1,2,3,4,5,6,7,8,9 };
	//初始化链表
	Init_ListNode(head, vec);
	TreeNode* root = solute.sortedListToBST(head);
	PreOrderTraverse(root);
	return 0;
}