分值算法（三）

实现归并排序

def merge_sort(nums)
	n = len(nums)
    if n <= 1:
        return nums
    mid = n //2
    left_li = merge_sort(nums[:mid])  # 嵌套递归，且上一级函数的执行需要下一级函数的返回值
    right_li = merge_sort(nums[mid:])
    
    left_pointer,right_pointer = 0,0
    result = []
    
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] < right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    
    return result
            
if __name__=='__main__'  :  
    li= [5,3,8,6,1,2,7]
    print(li)
    li=merge_sort(li)
    print(li)       

"""
程序执行过程

merge_sort([54,26,93,17,77,31,44,55,20])

    left_li = merge_sort [54,26,93,17]
        
        left_li = merge_sort[54,26]
         
            left_li = merge_sort[54]
            return [54]
            left_li = [54]
            right_li = [26]
            rerult =[26,54]
        return [26,54]
        
        right_li =merge_sort[93,17]
            left_li =merge[93]
            return [93]
            left_li = [93]
            right_li = merge_sort[17]
            return [17]
            right_li = [17]
        return [17,29]
        
        left_li = [26,54]
        right_li =[17,29]
    return [17,26,29,54]
    left_li =[17,26,29,54]
            
"""

2 leetcode 241

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。

def diffwaycompute(imput):
	if input.isdigit():
		return [int(input)]
	res = []
	for i ,char in enumerate(input):
		if char in ['-','+','*']:
			left_char = self.diffwaycompute(input[:i])
			right_char = self.diffwaycompute(input[i+1:])
			for l in left_char:
				for r in right_char:
					if char =='-':
						res.append(l-r)
					elif char == '+':
						res.append(l+r)
					else:
						res.append(l*r)
	return res

letecode95 不同的二插搜索树(2)

给定一个整数n,生成所有有1,2…n组成的节点的二叉搜索树

• 思路
  二叉搜索树关键的性质是根节点的值大于左子树所有节点的值，小于右子树所有节点的值，且左子树和右子树也同样为二叉搜索树。因此在生成所有可行的二叉搜索树的时候，假设当前序列长度为 n，如果我们枚举根节点的值为 i，那么根据二叉搜索树的性质我们可以知道左子树的节点值的集合为 [1…i-1]，右子树节点的集合为[i+1…n]而左子树和右子树的生成相较于原问题是一个序列长度缩小的子问题，因此我们可以想到用递归的方法来解决这道题目。

我们定义 generateTrees(start, end) 函数表示当前值的集合为[start,end],返回序列[start,end]生成的所有可行的二叉搜索树。按照上文的思路，我们考虑枚举[start,end]中的值i为当前二叉树的根节点，那么序列就划分为[start,i-1]和[i+1,end]两部分。我们递归调用这两部分，即 generateTrees(start, i - 1) 和generateTrees(i + 1, end)，获得所有可行的左子树和可行的右子树，那么最后一步我们只要从可行左子树集合中选一棵，再从可行右子树集合中选一棵拼接到根节点上，并将生成的二叉搜索树放入答案数组即可。
递归的入口即为 generateTrees(1, n)，出口为当 start>end\textit{start}>\textit{end}start>end 的时候，当前二叉搜索树为空，返回空节点即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class solution:
	def generateTree(self,n:int)->List[TreeNode]:
		def generateTree(start,end):
			if start > end:
				return [None]
			alltree = []
			for i in range(start,end+1):#遍历所有可能的根节点
			#递归的生成左右子树
				lefttree = generateTree(start,i-1)
				righttree = generateTree(i+1,end)
				for l in lefttree:
					for r in righttree:#左右子树进行组合
						curtree = TreeNode(i)#实例化以i为根节点的树
						curtree.left = l
						curtree.right = r
						alltree.append(curtree)
			return alltree
		return generateTree(1,n) if n else []