[pull] master from youngyangyang04:master #272

Original file line number	Diff line number	Diff line change
Expand Up		@@ -41,7 +41,7 @@

		那么我们就应该想到使用哈希法了。

	因为本地,我们不仅要知道元素有没有遍历过,还有知道这个元素对应的下标,需要使用 key value结构来存放,key来存元素,value来存下标,那么使用map正合适。
	因为本地,我们不仅要知道元素有没有遍历过,还要知道这个元素对应的下标,需要使用 key value结构来存放,key来存元素,value来存下标,那么使用map正合适。

		再来看一下使用数组和set来做哈希法的局限。

Expand Down

178 changes: 87 additions & 91 deletions problems/0098.验证二叉搜索树.md

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -371,117 +371,113 @@ class Solution {

		## Python

	递归 - 利用BST中序遍历特性,把树"压缩"成数组
	递归法(版本一)利用中序递增性质,转换成数组
		```python
	# 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 isValidBST(self, root: TreeNode) -> bool:
	# 思路: 利用BST中序遍历的特性.
	# 中序遍历输出的二叉搜索树节点的数值是有序序列
	candidate_list = []

	def __traverse(root: TreeNode) -> None:
	nonlocal candidate_list
	if not root:
	return
	__traverse(root.left)
	candidate_list.append(root.val)
	__traverse(root.right)

	def __is_sorted(nums: list) -> bool:
	for i in range(1, len(nums)):
	if nums[i] <= nums[i - 1]: # ⚠️ 注意: Leetcode定义二叉搜索树中不能有重复元素
	return False
	return True

	__traverse(root)
	res = __is_sorted(candidate_list)

	return res
	def __init__(self):
	self.vec = []

	def traversal(self, root):
	if root is None:
	return
	self.traversal(root.left)
	self.vec.append(root.val) # 将二叉搜索树转换为有序数组
	self.traversal(root.right)

	def isValidBST(self, root):
	self.vec = [] # 清空数组
	self.traversal(root)
	for i in range(1, len(self.vec)):
	# 注意要小于等于,搜索树里不能有相同元素
	if self.vec[i] <= self.vec[i - 1]:
	return False
	return True

		```

	递归 - 标准做法
	递归法(版本二)设定极小值,进行比较

		```python
		class Solution:
	def isValidBST(self, root: TreeNode) -> bool:
	# 规律: BST的中序遍历节点数值是从小到大.
	cur_max = -float("INF")
	def __isValidBST(root: TreeNode) -> bool:
	nonlocal cur_max

	if not root:
	return True

	is_left_valid = __isValidBST(root.left)
	if cur_max < root.val:
	cur_max = root.val
	else:
	return False
	is_right_valid = __isValidBST(root.right)

	return is_left_valid and is_right_valid
	return __isValidBST(root)
	def __init__(self):
	self.maxVal = float('-inf') # 因为后台测试数据中有int最小值

	def isValidBST(self, root):
	if root is None:
	return True

	left = self.isValidBST(root.left)
	# 中序遍历,验证遍历的元素是不是从小到大
	if self.maxVal < root.val:
	self.maxVal = root.val
	else:
	return False
	right = self.isValidBST(root.right)

	return left and right

		```
	递归 - 避免初始化最小值做法:
	递归法(版本三)直接取该树的最小值
		```python
	# 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 isValidBST(self, root: TreeNode) -> bool:
	# 规律: BST的中序遍历节点数值是从小到大.
	pre = None
	def __isValidBST(root: TreeNode) -> bool:
	nonlocal pre

	if not root:
	return True

	is_left_valid = __isValidBST(root.left)
	if pre and pre.val>=root.val: return False
	pre = root
	is_right_valid = __isValidBST(root.right)

	return is_left_valid and is_right_valid
	return __isValidBST(root)
	def __init__(self):
	self.pre = None # 用来记录前一个节点

	def isValidBST(self, root):
	if root is None:
	return True

	left = self.isValidBST(root.left)

	if self.pre is not None and self.pre.val >= root.val:
	return False
	self.pre = root # 记录前一个节点

	right = self.isValidBST(root.right)
	return left and right



		```
	迭代法
		```python
	迭代-中序遍历
	# 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 isValidBST(self, root: TreeNode) -> bool:
	def isValidBST(self, root):
		stack = []
		cur = root
	pre = None
	while cur or stack:
	if cur: # 指针来访问节点,访问到最底层
	pre = None # 记录前一个节点
	while cur is not None or len(stack) > 0:
	if cur is not None:
		stack.append(cur)
	cur = cur.left
	else: # 逐一处理节点
	cur = stack.pop()
	if pre and cur.val <= pre.val: # 比较当前节点和前节点的值的大小
	cur = cur.left # 左
	else:
	cur = stack.pop() # 中
	if pre is not None and cur.val <= pre.val:
		return False
	pre = cur
	cur = cur.right
	pre = cur # 保存前一个访问的结点
	cur = cur.right # 右
		return True

		```
	```python
	# 遵循Carl的写法,只添加了节点判断的部分
	class Solution:
	def isValidBST(self, root: TreeNode) -> bool:
	# method 2
	que, pre = [], None
	while root or que:
	while root:
	que.append(root)
	root = root.left
	root = que.pop()
	# 对第一个节点只做记录,对后面的节点进行比较
	if pre is None:
	pre = root.val
	else:
	if pre >= root.val: return False
	pre = root.val
	root = root.right
	return True
	```


		## Go

Expand Down

38 changes: 2 additions & 36 deletions problems/0106.从中序与后序遍历序列构造二叉树.md

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -400,8 +400,6 @@ public:
		};
		```

	## Python


		# 105.从前序与中序遍历序列构造二叉树

Expand Down Expand Up		@@ -692,38 +690,6 @@ class Solution {

		## Python

	```python
	class Solution:
	def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
	# 第一步: 特殊情况讨论: 树为空. 或者说是递归终止条件
	if not postorder:
	return

	# 第二步: 后序遍历的最后一个就是当前的中间节点
	root_val = postorder[-1]
	root = TreeNode(root_val)

	# 第三步: 找切割点.
	root_index = inorder.index(root_val)

	# 第四步: 切割inorder数组. 得到inorder数组的左,右半边.
	left_inorder = inorder[:root_index]
	right_inorder = inorder[root_index + 1:]

	# 第五步: 切割postorder数组. 得到postorder数组的左,右半边.
	# ⭐️ 重点1: 中序数组大小一定跟后序数组大小是相同的.
	left_postorder = postorder[:len(left_inorder)]
	right_postorder = postorder[len(left_inorder): len(postorder) - 1]


	# 第六步: 递归
	root.left = self.buildTree(left_inorder, left_postorder)
	root.right = self.buildTree(right_inorder, right_postorder)

	# 第七步: 返回答案
	return root
	```

		105.从前序与中序遍历序列构造二叉树

		```python
Expand Down Expand Up		@@ -752,7 +718,7 @@ class Solution:
		# 第六步: 递归
		root.left = self.buildTree(preorder_left, inorder_left)
		root.right = self.buildTree(preorder_right, inorder_right)

	# 第七步: 返回答案
		return root
		```

Expand Down Expand Up		@@ -784,7 +750,7 @@ class Solution:
		# 第六步: 递归
		root.left = self.buildTree(inorder_left, postorder_left)
		root.right = self.buildTree(inorder_right, postorder_right)

	# 第七步: 返回答案
		return root
		```

Expand Down

100 changes: 46 additions & 54 deletions problems/0108.将有序数组转换为二叉搜索树.md

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -316,73 +316,65 @@ class Solution {
		```

		## Python
	递归

	递归法
		```python
	# 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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
	'''
	构造二叉树:重点是选取数组最中间元素为分割点,左侧是递归左区间;右侧是递归右区间
	必然是平衡树
	左闭右闭区间
	'''
	# 返回根节点
	root = self.traversal(nums, 0, len(nums)-1)
	return root

		def traversal(self, nums: List[int], left: int, right: int) -> TreeNode:
	# Base Case
		if left > right:
		return None

	# 确定左右界的中心,防越界
		mid = left + (right - left) // 2
	# 构建根节点
	mid_root = TreeNode(nums[mid])
	# 构建以左右界的中心为分割点的左右子树
	mid_root.left = self.traversal(nums, left, mid-1)
	mid_root.right = self.traversal(nums, mid+1, right)

	# 返回由被传入的左右界定义的某子树的根节点
	return mid_root
	root = TreeNode(nums[mid])
	root.left = self.traversal(nums, left, mid - 1)
	root.right = self.traversal(nums, mid + 1, right)
	return root

	def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
	root = self.traversal(nums, 0, len(nums) - 1)
	return root

		```

	迭代(左闭右开)
	迭代法
		```python
	from collections import deque

		class Solution:
	def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
	if len(nums) == 0: return None
	root = TreeNode() # 初始化
	nodeSt = [root]
	leftSt = [0]
	rightSt = [len(nums)]

	while nodeSt:
	node = nodeSt.pop() # 处理根节点
	left = leftSt.pop()
	right = rightSt.pop()
	mid = left + (right - left) // 2
	node.val = nums[mid]

	if left < mid: # 处理左区间
	node.left = TreeNode()
	nodeSt.append(node.left)
	leftSt.append(left)
	rightSt.append(mid)

	if right > mid + 1: # 处理右区间
	node.right = TreeNode()
	nodeSt.append(node.right)
	leftSt.append(mid + 1)
	rightSt.append(right)
	def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
	if len(nums) == 0:
	return None

	root = TreeNode(0) # 初始根节点
	nodeQue = deque() # 放遍历的节点
	leftQue = deque() # 保存左区间下标
	rightQue = deque() # 保存右区间下标

	nodeQue.append(root) # 根节点入队列
	leftQue.append(0) # 0为左区间下标初始位置
	rightQue.append(len(nums) - 1) # len(nums) - 1为右区间下标初始位置

	while nodeQue:
	curNode = nodeQue.popleft()
	left = leftQue.popleft()
	right = rightQue.popleft()
	mid = left + (right - left) // 2

	curNode.val = nums[mid] # 将mid对应的元素给中间节点

	if left <= mid - 1: # 处理左区间
	curNode.left = TreeNode(0)
	nodeQue.append(curNode.left)
	leftQue.append(left)
	rightQue.append(mid - 1)

	if right >= mid + 1: # 处理右区间
	curNode.right = TreeNode(0)
	nodeQue.append(curNode.right)
	leftQue.append(mid + 1)
	rightQue.append(right)

		return root

		```

		## Go
Expand Down

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[pull] master from youngyangyang04:master #272

Uh oh!

[pull] master from youngyangyang04:master #272

Filter by extension

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!