leetcode刷题-二叉树06

530.二叉搜索树的最小绝对差

二叉搜索树 中序遍历 有序数组

代码随想录文档讲解
LeetCode

思路：

注意，这是二叉搜索树
遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。最直观的想法，就是把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值了。

伪代码c++：

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 __init__(self):
        self.vec = []
    def traversal(self, root):
        if not root:
            return
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.vec = []
        self.traversal(root)

        if len(self.vec) < 2:
            return 0
        res = self.vec[1] - self.vec[0]
        for i in range(1, len(self.vec)-1):
            res = min(res, self.vec[i+1]-self.vec[i])
        return res

# 解法二：使用指针记录节点的值，直接进行比较
# 题目条件：至少含有两个节点
class Solution:
    def __init__(self):
        self.res = float("inf")
        self.pre = None
    def traversal(self, cur):
        if cur is None:
            return
        self.traversal(cur.left)
        if self.pre is not None:
            self.res = min(self.res, cur.val - self.pre.val)
        self.pre = cur
        self.traversal(cur.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.traversal(root)
        return self.res

501.二叉搜索树中的众数

leetcode题目链接
代码随想录文档讲解

思路：

递归法使用前序遍历，
回溯法，

伪代码（C++）：

void travesal (TreeNode node, void<int> &path, vector<string> &result){
	// 中 要写在前面，否则会落下叶子节点
	path.push_back(node->val) 
	if(node->left==NULL && node->right==NULL){ //遍历到叶子节点回溯
		result.push_back(path); // path需要进行进一步处理，这里简化
		return;
	}
	// 左
	if(node->left){
		travesal(node->left, path, result); // 递归
		path.pop_back(); //回溯
	}
	// 右
	if(node->right){
		travesal(node->right, path, result);
		path.pop_back();
	}		
}

python代码：

class Solution:
    def traversal(self, cur, path, result):
        path.append(cur.val)
        if not cur.left and not cur.right:
            spath = '->'.join(map(str, path))
            result.append(spath)
        if cur.left:
            self.traversal(cur.left, path, result)
            path.pop()
        if cur.right:
            self.traversal(cur.right, path, result)
            path.pop()
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = list()
        path = list()
        if not root:
            return result
        self.traversal(root, path, result)
        return result

236. 二叉树的最近公共祖先

leetcode题目链接
代码随想录文档讲解

思路：

左叶子节点：叶子节点中 && 父节点的左孩子
要通过父节点判断子节点是不是我们要收集的元素，一层一层收集左叶子之和，向上返回
用后序遍历代码相对简洁 + 回溯

伪代码（C++）：

int traversal( TreeNode node ) {
	if(node==NULL) return 0;  // 空节点
	if(node->left==NULL && node->right==NULL) return 0; // 叶子节点
	// 左
	int leftNum = traversal(node->left);
	if(node->left != NULL && node->left->left==NULL && node->left->right==NULL){
		leftNum = node->left->val;
	}
	// 右
	int rightNum = traversal(node->right);
	// 中
	int sum = leftNum + rightNum;
	return sum;
}

python代码：

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        if not root.left and not root.right: return 0
        leftnum = self.sumOfLeftLeaves(root.left)
        if root.left and not root.left.left and not root.left.right:
            leftnum = root.left.val
        rightnum = self.sumOfLeftLeaves(root.right)
        Sum = leftnum + rightnum
        return Sum