关于python与C++递归区别：

python中的递归被限制在1000次以内
而c++则只有内存限制，不会出现次数限制

举例如下：

同样的有序链表生成平衡二叉搜索树的过程中：
如果用递归去实现：从中间取头节点，左子树在链表左边，右子树在链表右边，然后将左右链表重复上述过程，返回左右子树头节点。

python中限制了递归次数，因此只能采用循环实现了！

#include
using namespace std;

struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int _val) :val(_val), left(NULL), right(NULL) {};
};

struct ListNode {
int val;
ListNode* next;
ListNode(int _val) : val(_val), next(NULL) {};
};

class Solution {
public:
TreeNode* bfs(vector& nodelist) {
int nodelist_l = nodelist.size();
TreeNode* head = NULL;// new TreeNode();
if (nodelist_l == 0) {
return head;
}
else if (nodelist_l % 2 == 0) {
head = new TreeNode(nodelist[nodelist_l/2]);
vector leftnodelist = { nodelist.begin(), nodelist.begin() + nodelist_l / 2 };
vector rightnodelist = { nodelist.begin() + nodelist_l / 2 + 1, nodelist.end()};
TreeNode* leftnode = bfs(leftnodelist);
TreeNode* rightnode = bfs(rightnodelist);
head->left = leftnode;
head->right = rightnode;
}
else if (nodelist_l % 2 == 1) {
head = new TreeNode(nodelist[(nodelist_l - 1) / 2]);
vector leftnodelist = { nodelist.begin(), nodelist.begin() + (nodelist_l - 1) / 2 };
vector rightnodelist = { nodelist.begin() + (nodelist_l - 1) / 2 + 1, nodelist.end() };
TreeNode* leftnode = bfs(leftnodelist);
TreeNode* rightnode = bfs(rightnodelist);
head->left = leftnode;
head->right = rightnode;
}
return head;
}

TreeNode* sortedListToBST(ListNode* head) {
	vector<int> nodelist;
	while (head != NULL) {
		nodelist.push_back(head->val);
		head = head->next;
	}
	return bfs(nodelist);
}

};

int main() {
Solution solution;
solution.sortedListToBST();

}

-- coding: utf-8 --

“”"
Created on Wed Jun 14 21:15:51 2023

@author: Admin
“”"

class TreeNode:
def init(self, x):
self.val = x
self.left = None
self.right = None

class ListNode:
def init(self, x):
self.val = x
self.next = None

class Solution:

def bfs(self, nodelist:list):
    nodelist_l = len(nodelist)
    head = None
    if nodelist_l == 0:
        return head
    elif nodelist_l % 2 == 0:
        head = TreeNode(nodelist[int(nodelist_l/2)])
        leftnodelist = nodelist[0:int(nodelist_l/2)]
        rightnodelist = nodelist[int(nodelist_l/2):nodelist_l]
        leftnode = self.bfs(leftnodelist)
        rightnode = self.bfs(rightnodelist)
        head.left = leftnode
        head.right = rightnode
    elif nodelist_l % 2 == 1:
        head = TreeNode(nodelist[int((nodelist_l-1)/2)])
        leftnodelist = nodelist[0:int((nodelist_l-1)/2)]
        rightnodelist = nodelist[int((nodelist_l-1)/2):nodelist_l]
        leftnode = self.bfs(leftnodelist)
        rightnode = self.bfs(rightnodelist)
        head.left = leftnode
        head.right = rightnode
    return head
    

def sortedListToBST(self,head:ListNode):
    nodelist = []
    while head != None:
        nodelist.append(head.val)
        head=head.next
    return self.bfs(nodelist)