数据结构——二叉树

戏拈秃笔

已于 2024-04-01 22:22:52 修改

阅读量395

点赞数 1

分类专栏：数据结构与算法（java版）文章标签：数据结构算法

于 2024-03-26 23:17:09 首次发布

本文链接：https://blog.csdn.net/weixin_72052233/article/details/137057958

版权

数据结构与算法（java版）专栏收录该内容

39 篇文章 1 订阅

订阅专栏

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

要求：一些基本的数据结构的定义要能够手写代码出来
学习思路：
先去B站上看一些介绍二叉树基础知识的视频，了解二叉树大概涉及哪些内容，重难点又是什么
然后去力扣上搜二叉树相关的热门题单，从基础部分开始刷，从代码的角度了解二叉树的特性（刚开始不会就看答案，刷多了就熟了）
题目做出来后，再想办法优化自己的代码
代码看不懂，就去B站搜视频看别人讲解

常用二叉树：（掌握这四种，平常做题就够了）

满二叉树
完全二叉树
二叉搜索树：对于二叉搜索树中的每个结点，其左子结点的值小于该结点的值，而右子结点的值大于该结点的值
平衡二叉搜索树：每个结点的子树
的高度差距为0或1

二叉树的三种遍历方式：（面试考点）
两大遍历方式：
深度优先搜索
广度优先搜索
两种遍历方式
递归法
迭代法

二叉树的三种遍历方式：（递归法）

//定义结点类
public class Node{
	public int value;
	public Node left;
	public Node right;
	public Node(int data) {
		this.value=data;
	}
}
//前序遍历
public void preOrderRecur(Node head) {
	if(head==null) {
		return;
	}
	System.out.print(head.value+" ");
	preOrderRecur(head.left);
	preOrderRecur(head.right);
}
//中序遍历
public void inOrderRecur(Node head) {
	if(head==null) {
		return;
	}
	inOrderRecur(head.left);
	System.out.print(head.value+" ");
	inOrderRecur(head.right);
}
//后序遍历
public void posOrderRecur(Node head) {
	if(head==null) {
		return;
	}
	posOrderRecur(head.left);
	posOrderRecur(head.right);
	System.out.print(head.value+" ");
}

二叉树的三种遍历方式：（非递归法）

1、前序遍历

public void preOrderUnRecur(Node head) {
	System.out.print("pre-order:");
	if(head!=null) {
		Stack<Node> stack=new Stack<Node>();
		stack.add(head);//将头节点压入栈中
		while(!stack.isEmpty()) {
			head=stack.pop();//弹出栈顶节点
			System.out.print(head.value+" ");
			if(head.right!=null) {
				stack.push(head.right);//压入当前节点的右孩子节点
			}
			if(head.left!=null) {
				stack.push(head.left);//压入当前节点的左孩子节点
			}
		}
	}
	System.out.println();
}

2、中序遍历

public void inOrderUnRecur(Node head) {
	System.out.print("in-order:");
	if(head!=null) {
		Stack<Node> stack=new Stack<Node>();
		while(!stack.isEmpty() || head!=null) {
			if(head!=null) {
				stack.add(head);
				head=head.left;
			}else {
				head=stack.pop();
				System.out.print(head.value+" ");
				head=head.right;
			}
		}
	}
	System.out.println();
}

3、后序遍历

public void posOrderUnRecur(Node head) {
	System.out.print("pos-order:");
	if(head!=null) {
		Stack<Node> s1=new Stack<Node>();
		Stack<Node> s2=new Stack<Node>();
		s1.push(head);
		while(!s1.isEmpty()) {
			head=s1.pop();
			s2.push(head);
			if(head.left!=null) {
				s1.push(head.left);
			}
			if(head.right!=null) {
				s1.push(head.right);
			}
		}
		while(!s2.isEmpty()) {
			System.out.print(s2.pop().value+" ");
		}
	}
	System.out.println();
}

二叉树的广度优先搜索：

迭代法：

public void levelOrder(Node head) {
    System.out.print("level-order: ");
    if (head != null) {
        Queue<Node> queue = new LinkedList<>(); // 使用队列保存节点，先进先出
        queue.offer(head); // 将头节点加入队列

        while (!queue.isEmpty()) {
            head = queue.poll(); // 弹出队列头部节点
            System.out.print(head.value + " ");

            if (head.left != null) {
                queue.offer(head.left); // 将左子节点加入队列
            }
            if (head.right != null) {
                queue.offer(head.right); // 将右子节点加入队列
            }
        }
    }
    System.out.println();
}

二叉树的深度优先搜索：

一、94. 二叉树的中序遍历

法一：递归法（套用上面的模板）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<Integer> list=new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root==null){
            return list;
        }
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);
        return list;
    }
}

法二：迭代法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            while(!stack.isEmpty() || root!=null){
                if(root!=null){
                    stack.add(root);
                    root=root.left;
                }else{
                    root=stack.pop();
                    list.add(root.val);
                    root=root.right;
                }
            }       
        }
        return list;
    }
}

二、102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

难点在于，如何将同一层节点的值加入到同一个子链表

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>(); // 用于存放最终的层序遍历结果
        if (root == null) {
            return result;
        }
        
        Queue<TreeNode> queue = new LinkedList<>(); // 使用队列辅助进行层序遍历
        queue.offer(root); // 将根节点加入队列
        
        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // 当前层的节点数
            List<Integer> currentLevel = new ArrayList<>(); // 存放当前层的节点值
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); // 出队一个节点
                currentLevel.add(node.val); // 将节点值加入当前层列表
                if (node.left != null) {
                    queue.offer(node.left); // 左子节点入队
                }
                if (node.right != null) {
                    queue.offer(node.right); // 右子节点入队
                }
            }
            result.add(currentLevel); // 当前层遍历结束，将当前层节点值列表加入最终结果
        }
        
        return result;
    }
}

三、104. 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：

输入：root = [1,null,2]
输出：2

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {//使用深度优先搜索（DFS）/递归
        if (root == null) {
            return 0;
        } else {
            int leftDepth = maxDepth(root.left);
            int rightDepth = maxDepth(root.right);
            return Math.max(leftDepth, rightDepth) + 1;
        }
    }
}

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

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均无重复元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        // 使用HashMap存储中序遍历结果的值和对应的索引，以便快速查找节点在中序遍历中的位置
        HashMap<Integer, Integer> indexMap = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            indexMap.put(inorder[i], i);
        }
        return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, indexMap);
    }

    private TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, HashMap<Integer, Integer> indexMap) {
        // 判断边界情况，如果起始位置大于结束位置，返回null
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }

        // 根据先序遍历结果确定根节点的值
        int rootVal = preorder[preStart];
        TreeNode root = new TreeNode(rootVal);

        // 在中序遍历中找到根节点的位置
        int rootIndex = indexMap.get(rootVal);
        // 计算左子树的大小
        int leftSubtreeSize = rootIndex - inStart;

        // 递归构建左子树和右子树
        root.left = buildTree(preorder, preStart + 1, preStart + leftSubtreeSize, inorder, inStart, rootIndex - 1, indexMap);
        root.right = buildTree(preorder, preStart + leftSubtreeSize + 1, preEnd, inorder, rootIndex + 1, inEnd, indexMap);

        return root;
    }
}

五、543. 二叉树的直径

给你一棵二叉树的根节点，返回该树的直径。

二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的长度由它们之间边数表示。

示例 1：

输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2：

输入：root = [1,2]
输出：1

提示：

树中节点数目在范围 [1, 104] 内
-100 <= Node.val <= 100

分析：

在计算二叉树的直径时，需要考虑的情况是直径路径可能经过根节点，也可能不经过根节点。因此，我们在计算直径时需要分别考虑这两种情况：

如果直径路径经过根节点：直径长度为左子树的最大深度加上右子树的最大深度。
如果直径路径不经过根节点：直径在左子树或右子树中，而不经过根节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int diameterOfBinaryTree(TreeNode root) {
        if (root == null) {
            return 0;
        }
        //我们需要调用 maxDepth 方法来计算左右子树的深度，同时还需要递归地计算左右子树的直径
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        int leftDiameter = diameterOfBinaryTree(root.left);
        int rightDiameter = diameterOfBinaryTree(root.right);
        return Math.max(leftDepth + rightDepth, Math.max(leftDiameter, rightDiameter));
    }

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

六、114. 二叉树展开为链表

给你二叉树的根结点 root ，请你将它展开为一个单链表：

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树先序遍历顺序相同。

示例 1：
输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [0]
输出：[0]
提示：

树中结点数在范围 [0, 2000] 内
-100 <= Node.val <= 100

分析：

把根部和右侧断开，把左侧塞进去后，再接好，再断，再接……

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        // 递归结束条件
        if (root == null) {
            return;
        }
        
        // 展开左子树
        flatten(root.left);
        // 展开右子树
        flatten(root.right);

        // 保存右子树（相当于根部和右侧断开，把左侧塞进去后，再接好）
        TreeNode temp = root.right;
        // 将左子树接到根节点的右侧
        root.right = root.left;
        root.left = null;

        // 找到新右子树现在的最右节点
        while (root.right != null) {
            root = root.right;
        }

        // 将之前保存的右子树接到现在的最右节点上
        root.right = temp;
    }
}

七、226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]
提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

分析：

与上面第六题类似
从最上面的根节点开始，往下，交换左右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return root;
        }
        invertTree(root.left);
        invertTree(root.right);

        //交换左右子树
        TreeNode temp=root.right;
        root.right=root.left;
        root.left=temp;        
        return root;
    }

}

八、101. 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

递归法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isMirror(root, root);
    }
    
    public boolean isMirror(TreeNode t1, TreeNode t2) {
        //两个节点同时为空，停止递归
        if (t1 == null && t2 == null) {
            return true;
        }
        //两个节点不同时为空，一定不对称 
        if (t1 == null || t2 == null) {
            return false;
        }
        // 判断当前节点的值是否相等，并且左子树的左子树与右子树的右子树、左子树的右子树与右子树的左子树是否镜像对称
        return (t1.val == t2.val) && isMirror(t1.left, t2.right) && isMirror(t1.right, t2.left);
    }
}

迭代法：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        // 创建一个队列，用于迭代处理节点
        Queue<TreeNode> queue = new LinkedList<>();
        // 初始时将根节点入队两次，分别走左边、右边
        queue.add(root);
        queue.add(root);
        
        // 迭代处理队列中的节点
        while (!queue.isEmpty()) {
            // 每次从队列中取出两个节点进行比较
            TreeNode t1 = queue.poll();
            TreeNode t2 = queue.poll();
            
            // 如果两个节点同时为null，则继续下一轮迭代
            if (t1 == null && t2 == null) continue;
            // 如果两个节点中有一个为null，或者节点值不相等，则返回false
            if (t1 == null || t2 == null || t1.val != t2.val) return false;
            
            // 队列是先进先出的，所以一次取两个，比较的是t1.left和t2.right
            queue.add(t1.left);
            queue.add(t2.right);
            queue.add(t1.right);
            queue.add(t2.left);
        }
        
        // 如果迭代完成后没有返回false，则说明树是对称的
        return true;
    }
}

九、617. 合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：
输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]
示例 2：
输入：root1 = [1], root2 = [1,2]
输出：[2,2]
提示：

两棵树中的节点数目在范围 [0, 2000] 内
-104 <= Node.val <= 104

分析：

把root1中多于root2的部分嫁接到root2中
最终把root2当结果返回

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {//返回root1中不为空的部分，嫁接到root2中
            return root1;
        }
        
        root2.val += root1.val;
        root2.left = mergeTrees(root1.left, root2.left);//调用mergeTrees()方法返回的是子树
        root2.right = mergeTrees(root1.right, root2.right);
        
        return root2;
    }
}

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

分析：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null || root==p || root==q){
            return root;
        }
        TreeNode left=lowestCommonAncestor(root.left,p,q);
        TreeNode right=lowestCommonAncestor(root.right,p,q);
        if(left!=null && right!=null){
            return root;
        }
        return left!=null?left:right;
    }
}

十一、437. 路径总和III

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的路径的数目。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

示例 1：
输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出：3
解释：和等于 8 的路径有 3 条，如图所示。
示例 2：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：3
提示:

二叉树的节点个数的范围是 [0,1000]
-109 <= Node.val <= 109
-1000 <= targetSum <= 1000

分析：

访问每一个节点 node，检测以 node 为起始节点且向下延深的路径有多少种。

我们递归遍历每一个节点的所有可能的路径，然后将这些路径数目加起来即为返回结果。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return 0;
        }
        long ts=(long)targetSum;
        //遍历所有节点
        int ret = rootSum(root, ts);
        ret += pathSum(root.left, (int)ts);
        ret += pathSum(root.right, (int)ts);
        return ret;
    }
    //遍历当前节点的所有可能的路径
    public int rootSum(TreeNode root, long targetSum) {
        int ret = 0;

        if (root == null) {
            return 0;
        }
        long val = (long)root.val;//因为测试数据有些超出了int数据类型的范围，所以要转为long型进行减法计算
        if (val == targetSum) {
            ret++;
        } 

        ret += rootSum(root.left, targetSum - val);
        ret += rootSum(root.right, targetSum - val);
        return ret;
    }
}