LeetCodeHot100 二叉树 94. 二叉树的中序遍历 104. 二叉树的最大深度 101. 对称二叉树 543. 二叉树的直径 102. 二叉树的层序遍历 108. 将有序数组转换为二叉搜索树 98. 验证二叉搜索树 230. 二叉搜索树中第K小的元素 199. 二叉树的右视图 114. 二叉树展开为链表

合集 - LeetCode Hot100(10)
1.LeetCodeHot100 哈希 1.两数之和 46.字母异位词分组 128.最长连续序列2.LeetCodeHot100 双指针 283. 移动零 11. 盛最多水的容器 15. 三数之和 42. 接雨水3.LeetCodeHot100 73. 矩阵置零 54. 螺旋矩阵 48. 旋转图像 240. 搜索二维矩阵 II4.LeetCodeHot100 二分查找 35. 搜索插入位置 74. 搜索二维矩阵 34. 在排序数组中查找元素的第一个和最后一个位置 33. 搜索旋转排序数组 153. 寻找旋转排序数组中的最小值5.LeetCodeHot100 堆 215. 数组中的第K个最大元素 347. 前 K 个高频元素6.LeetCodeHot100 栈 155. 最小栈 394. 字符串解码7.LeetCodeHot100 数组 53. 最大子数组和 56. 合并区间 238. 除自身以外数组的乘积 41. 缺失的第一个正数8.LeetCodeHot100 链表 160. 相交链表 206. 反转链表 234. 回文链表 141. 环形链表 142. 环形链表 II 21. 合并两个有序链表 2. 两数相加 19. 删除链表的倒数第 N 个结点 24. 两两交换链表中的节点 25. K 个一组翻转链表 138. 随机链表的复制 148. 排序链表 23. 合并 K 个升序链表9.LeetCodeHot100 动态规划 70. 爬楼梯 118. 杨辉三角 198. 打家劫舍 279. 完全平方数 322. 零钱兑换
10.LeetCodeHot100 二叉树 94. 二叉树的中序遍历 104. 二叉树的最大深度 101. 对称二叉树 543. 二叉树的直径 102. 二叉树的层序遍历 108. 将有序数组转换为二叉搜索树 98. 验证二叉搜索树 230. 二叉搜索树中第K小的元素 199. 二叉树的右视图 114. 二叉树展开为链表
收起

94. 二叉树的中序遍历
https://leetcode.cn/problems/binary-tree-inorder-traversal/description/?envType=study-plan-v2&envId=top-100-liked

//    递归
//    List<Integer> resList;
//    public List<Integer> inorderTraversal(TreeNode root) {
//        resList = new ArrayList<>();
//        inorderHelper(root);
//        return resList;
//    }
//    public void inorderHelper(TreeNode node){
//        if (node == null) return;
//        inorderHelper(node.left);
//        resList.add(node.val);
//        inorderHelper(node.right);
//    }

//迭代
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> resList = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList<>();
        while (root != null || !deque.isEmpty()){
            if (root != null){
                deque.addLast(root);
                root = root.left;
            }else {
                root = deque.pollLast();
                resList.add(root.val);
                root = root.right;
            }
        }
        return resList;
    }

104. 二叉树的最大深度
https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/?envType=study-plan-v2&envId=top-100-liked

public int maxDepth(TreeNode root) {
        return max(root);
    }
    public int max(TreeNode node){
        if (node == null) return 0;
        int left = max(node.left);
        int right = max(node.right);
        return Math.max(left,right) + 1;
    }

总结：后序遍历 需要左右子树的信息。左右最深者+1
226. 翻转二叉树
https://leetcode.cn/problems/invert-binary-tree/?envType=study-plan-v2&envId=top-100-liked

public TreeNode invertTree(TreeNode root) {
        invertLeftAndRight(root);
        return root;
    }
    public void invertLeftAndRight(TreeNode node){
        if (node == null) return;
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
        invertLeftAndRight(node.left);
        invertLeftAndRight(node.right);
    }

总结：前序遍历，每次交换左和右
101. 对称二叉树
https://leetcode.cn/problems/symmetric-tree/description/?envType=study-plan-v2&envId=top-100-liked

public boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }
    public boolean compare(TreeNode left,TreeNode right){
        if (left == null && right != null) return false;
        if (left != null && right == null) return false;
        if (left == null && right == null) return true;
        if (left.val != right.val) return false;
        boolean out = compare(left.left,right.right);
        boolean in = compare(left.right,right.left);
        return in && out;
    }

总结：递归函数要两个节点，两个节点就是要比对的节点，前序，每次结束之后都去看外侧和内侧。
543. 二叉树的直径
https://leetcode.cn/problems/diameter-of-binary-tree/description/?envType=study-plan-v2&envId=top-100-liked

int diameter;
    public int diameterOfBinaryTree(TreeNode root) {
        diameter = 0;
        diameterHelper(root);
        return diameter;
    }
    public int diameterHelper(TreeNode node){
        if (node == null) return 0;
        int depthLeft = diameterHelper(node.left);
        int depthRight = diameterHelper(node.right);
        diameter = Math.max(depthLeft + depthRight,diameter);
        return Math.max(depthLeft,depthRight) + 1;
    }

总结：后序，每个节点当前的直径就是当前的左子树深度+右子树深度。
102. 二叉树的层序遍历
https://leetcode.cn/problems/binary-tree-level-order-traversal/description/?envType=study-plan-v2&envId=top-100-liked

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<>();
        Deque<TreeNode> deque = new LinkedList<>();
        if (root == null) return resList;
        deque.addLast(root);
        while (!deque.isEmpty()){
            int len = deque.size();
            List<Integer> tempList = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                TreeNode node = deque.pollFirst();
                tempList.add(node.val);
                if (node.left != null) deque.addLast(node.left);
                if (node.right != null) deque.addLast(node.right);
            }
            resList.add(new ArrayList<>(tempList));
        }
        return resList;
    }

总结：。。。
108. 将有序数组转换为二叉搜索树
https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked

public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums,0,nums.length-1);
    }
    public TreeNode helper(int[] nums,int start,int end){
        if (start > end) return null;
        int mid = start + (end - start) / 2;
        TreeNode treeNode = new TreeNode(nums[mid]);
        treeNode.left = helper(nums,start,mid - 1);
        treeNode.right = helper(nums,mid + 1,end);
        return treeNode;
    }

总结：二分查找去构造新节点。
98. 验证二叉搜索树
https://leetcode.cn/problems/validate-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked

TreeNode pre = null;
    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        boolean left = isValidBST(root.left);
        if (left == false) return false;
        if (pre != null && root.val <= pre.val){
            return false;
        }
        pre = root;
        boolean right = isValidBST(root.right);
        return right;
    }

总结：我们知道二叉搜索树的中序遍历是从小到大，那只要中序遍历的时候每次看当前节点和前一个节点的值是否满足当前节点>上一个几点即可判断是不是二叉搜索树。
230. 二叉搜索树中第K小的元素
https://leetcode.cn/problems/kth-smallest-element-in-a-bst/description/?envType=study-plan-v2&envId=top-100-liked

    int res = 0;
    int k;
    public int kthSmallest(TreeNode root, int k) {
        this.k = k;
        inorder(root);
        return res;
    }
    public void inorder(TreeNode node){
        if (node == null) return;
        inorder(node.left);
        if (k == 1) {
            res = node.val;
            k--;
            return;
        }else {
            k--;
        }
        inorder(node.right);
    }

总结：指定一个计数器，每然后中序遍历，到计数器的时候就放进res中
199. 二叉树的右视图
https://leetcode.cn/problems/binary-tree-right-side-view/description/?envType=study-plan-v2&envId=top-100-liked

public List<Integer> rightSideView(TreeNode root) {
        List<Integer> resList = new ArrayList<>();
        if (root == null) return resList;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.addLast(root);
        while (!deque.isEmpty()){
            int len = deque.size();
            for (int i = 0; i < len; i++) {
                TreeNode treeNode = deque.pollFirst();
                if (i == len - 1) resList.add(treeNode.val);
                if (treeNode.left != null) deque.addLast(treeNode.left);
                if (treeNode.right != null) deque.addLast(treeNode.right);
            }
        }
        return resList;
    }

总结：层序遍历，拿每层的最后一个。
114. 二叉树展开为链表
https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/description/?envType=study-plan-v2&envId=top-100-liked

public void flatten(TreeNode root) {
		if(root==null) {
			return;
		}
		LinkedList<TreeNode> res = new LinkedList<TreeNode>();
		//前序遍历整棵二叉树
		dfs(root,res);
		TreeNode head = res.removeFirst();
		head.left = null;
		//遍历链表，将链表中的TreeNode节点前后串联起来
		while(res.size()>0) {
			TreeNode tmp = res.removeFirst();			
			tmp.left = null;
			head.right = tmp;
			head = head.right;
		}	
	}
	
	//前序遍历整棵二叉树，并将遍历的结果放到数组中
	void dfs(TreeNode root, List<TreeNode> res) {
		if(root==null) {
			return;
		}
		res.add(root);
		dfs(root.left,res);
		dfs(root.right,res);
	}

总结：先序遍历每个节点，存下来，再操作。

posted @   jeasonGo  阅读(5)  评论(0)  编辑  收藏  举报
相关博文：
·  代码随想录算法训练营第二十一天，二十二，二十三| 530. 二叉搜索树的最小绝对差 501. 二叉搜索树中的众数 236. 二叉树的最近公共祖先 235. 二叉搜索树的最近公共祖先 701. 二叉搜索树中的插入操作 450. 删除二叉搜索树中的节点
·  代码随想录算法训练营第十六天| 104. 二叉树的最大深度 111. 二叉树的最小深度 222. 完全二叉树的节点个数
·  day13: 第六章 二叉树part01 |二叉树的前序遍历,后序遍历,中序遍历,（递归。层序（广度）跟迭代遍历）
·  leetcode中的二叉树
·  【LeetCode二叉树#02】二叉树层序遍历（广度优先搜索），十合一专题
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
点击右上角即可分享
微信分享提示
AI IDE Trae