- 二叉树的最大深度
ts
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function maxDepth(root: TreeNode | null): number {
if (!root) {
return 0
}
let max = 0
const func = (tree: TreeNode, len: number) => {
max = Math.max(max, len)
if (tree.left) {
func(tree.left, len + 1)
}
if (tree.right) {
func(tree.right, len + 1)
}
}
func(root, 1)
return max
};
- 看解答有个超炫的方法
function maxDepth(root: TreeNode | null): number {
if (root === null) return 0;
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1
};
py
# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
if root is None:
return 0
self.inn = 0
def func_dii(node: Optional[TreeNode],i:int):
self.inn = max(self.inn, i)
if node != None and node.left != None:
func_dii(node.left,i+1)
if node != None and node.right != None:
func_dii(node.right,i+1)
func_dii(root,1)
return self.inn
C#
public class Solution {
public int MaxDepth(TreeNode root) {
if(root == null){
return 0;
}
int inn = 0;
void func(TreeNode node,int len){
inn = Math.Max(len, inn);
if(node!=null && node.left!= null){
func(node.left,len+1);
}
if(node!=null && node.right!=null){
func(node.right,len+1);
}
}
func(root,1);
return inn;
}
}
- 验证二叉搜索树
ts
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function isValidBST(root: TreeNode | null): boolean {
if (!root) return false
const hasF = (node: TreeNode, min: number, max: number): boolean => {
if (node) {
if (node.val > min && node.val < max) {
let boo1 = true
let boo2 = true
if (node.left) {
boo1 = hasF(node.left, min, Math.min(node.val, max))
}
if (node.right) {
boo2 = hasF(node.right, Math.max(node.val, min), max)
}
return boo1 && boo2
} else {
return false
}
} else {
return true
}
}
return hasF(root, -Infinity, Infinity)
};
py
# 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: Optional[TreeNode]) -> bool:
if root == None:
return False
def hasF(node:Optional[TreeNode],_min:int,_max:int):
if node == None:
return True
else:
if node.val > _min and node.val < _max:
return hasF(node.left,_min,min(_max,node.val)) and hasF(node.right,max(_min,node.val),_max)
else:
return False
return hasF(root, float('-inf'), float('inf'))
- 对称二叉树
ts
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function isSymmetric(root: TreeNode | null): boolean {
const isMirror = (l: TreeNode, r: TreeNode) => {
const queue = [l, r]
while (queue.length) {
const u = queue.shift()
const v = queue.shift()
if (!u && !v) continue
if (!u || !v || u.val !== v.val) return false
queue.push(u.left, v.right)
queue.push(v.left, u.right)
}
return true
}
return isMirror(root.left, root.right)
};
- 二叉树的层序遍历
ts
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function levelOrder(root: TreeNode | null): number[][] {
if (!root) return []
let list: number[][] = new Array()
const getList = (nodes: TreeNode[]) => {
let nextnodes: TreeNode[] = new Array()
let nums: number[] = new Array()
for (let i = 0; i < nodes.length; i++) {
if (nodes[i].val !== null) nums.push(nodes[i].val)
if (nodes[i].left) nextnodes.push(nodes[i].left)
if (nodes[i].right) nextnodes.push(nodes[i].right)
}
list.push(nums)
if (nextnodes.length) {
getList(nextnodes)
}
}
getList([root])
return list
};
- 将有序数组转换为二叉搜索树
ts
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function sortedArrayToBST(nums: number[]): TreeNode | null {
const helper = (left: number, right: number): TreeNode => {
if (left > right) return null
let mid = Math.ceil((left + right) / 2)
let node = new TreeNode(nums[mid])
node.left = helper(left, mid - 1)
node.right = helper(mid + 1, right)
return node
}
return helper(0, nums.length - 1)
};