点击上方“罗晓胜”,马上关注,您的支持对我帮助很大
/ 前言 /
二叉树(Binary tree)是树形结构的一个重要类型。
许多实际问题抽象出来的数据结构往往是二叉树形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。
二叉树特点是每个节点最多只能有两棵子树,且有左右之分。
例:
1
2 3
/ 正文 /
反转二叉树(Invert a binary tree)
题目:
将二叉树的两个孩子换位置,即左变右,右变左。
解题思路:
方法一:循环,栈存储(DFS,非递归)
本质思想是,左右节点进行交换,循环翻转每个节点的左右子节点,将未翻转的子节点存入栈中,循环直到栈里所有节点都循环交换完为止。
方法二:循环,队列存储(BFS,非递归)
本质思想是,左右节点进行交换,循环翻转每个节点的左右子节点,将未翻转的子节点存入队列中,循环直到栈里所有节点都循环交换完为止。
方法三:递归
本质思想也是左右节点进行交换,交换前递归调用对根结点的左右节点分别进行处理,保证交换前左右节点已经翻转。
代码实现(栈实现):
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()) {
final TreeNode node = stack.pop();
final TreeNode left = node.left;
node.left = node.right;
node.right = left;
if(node.left != null) {
stack.push(node.left);
}
if(node.right != null) {
stack.push(node.right);
}
}
return root;
}
队列实现
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
TreeNode left = node.left;
node.left = node.right;
node.right = left;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
return root;
}
递归实现
public TreeNode invertTree(TreeNode node) {
if (node == null) {
return null;
}
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
invertTree(node.left);
invertTree(node.right);
return node;
}
重建二叉树
题目:
输入二叉树的前序遍历和中序遍历的结果,重建出该二叉树。
假设前序遍历和中序遍历结果中都不包含重复的数字,例如输入的前序遍历序列 {1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
重建出二叉树。
解题思路:
前序遍历第一个结点是父结点,中序遍历如果遍历到父结点,那么父结点前面的结点是左子树的结点,后边的结点的右子树的结点,这样我们可以找到左、右子树的前序遍历和中序遍历,我们可以用同样的方法去构建左右子树,可以用递归完成。
代码:
public class BinaryTreeNode {
public static int value;
public BinaryTreeNode leftNode;
public BinaryTreeNode rightNode;
}
public class Solution {
public static BinaryTreeNode constructCore(int[] preorder, int[] inorder) throws Exception {
if (preorder == null || inorder == null) {
return null;
}
if (preorder.length != inorder.length) {
throw new Exception("长度不一样,非法的输入");
}
BinaryTreeNode root = new BinaryTreeNode();
for (int i = 0; i < inorder.length; i++) {
if (inorder[i] == preorder[0]) {
root.value = inorder[i];
System.out.println(root.value);
root.leftNode = constructCore(Arrays.copyOfRange(preorder, 1, i + 1),
Arrays.copyOfRange(inorder, 0, i));
root.rightNode = constructCore(Arrays.copyOfRange(preorder, i + 1, preorder.length),
Arrays.copyOfRange(inorder, i + 1, inorder.length));
}
}
return root;
}
}
二叉树遍历
二叉树的遍历(traversing binary tree)是指从根结点出发,按照某种次序依次访问二叉树中所有的结点,使得每个结点被访问依次且仅被访问一次。 四种遍历方式分别为:先序遍历、中序遍历、后序遍历、层序遍历。
正常的一个满节点,A:根节点、B:左节点、C:右节点,
- 前序顺序是ABC(根节点排最先,然后同级先左后右);
- 中序顺序是BAC(先左后根最后右);
- 后序顺序是BCA(先左后右最后根)。
例:
1
2 3
4 5 6 7
- 前序遍历结果:1 2 4 5 3 6 7
- 中序遍历结果:4 2 5 1 6 3 7
- 后序遍历结果:4 5 2 6 7 3 1
创建一个二叉树
遍历之前,我们首先介绍一下,如何创建一个二叉树,在这里用的是先建左树再建右树的方法。
首先要声明结点TreeNode类,代码如下:
public class TreeNode {
public int data;
public TreeNode leftChild;
public TreeNode rightChild;
public TreeNode(int data){
this.data = data;
}
}
再来创建一颗二叉树:
/**
* 构建二叉树
* @param list 输入序列
* @return
*/
public static TreeNode createBinaryTree(LinkedList<Integer> list){
TreeNode node = null;
if(list == null || list.isEmpty()){
return null;
}
Integer data = list.removeFirst();
if(data!=null){
node = new TreeNode(data);
node.leftChild = createBinaryTree(list);
node.rightChild = createBinaryTree(list);
}
return node;
}
上面创建的二叉树的单向二叉树,思考一下该如何改造。
创建一颗满二叉树:
/**
* 创建完全二叉树
* @param list 源数据
* @param index 当前索引值
* @return 创建好的节点
*/
public static TreeNode createCompleteTree(LinkedList<Integer> list, int index) {
TreeNode newNode = null;
//保证index不会越界
if(index < list.size()){
newNode = new TreeNode(list.get(index));
newNode.leftChild = createCompleteTree(list, 2 * index + 1);
newNode.rightChild = createCompleteTree(list, 2 * index + 2);
}
return newNode;
}
...
//调用
TreeNode completeTree = createCompleteTree(list, 0);
生成满二叉树算法解析:
原始list:{1,2,3,4,5,6,7}
期望结果:
1
2 3
4 5 6 7
不难分析,index之间的对应关系:
Index=0 子节点Index:1 2
Index=1 子节点Index:3 4
Index=2 子节点Index:5 6
规律就是当节点Index为n时,子节点Index分别为2n+1、2n+2
前序遍历
实现代码如下:
/**
* 二叉树前序遍历 根-> 左-> 右
* @param node 二叉树节点
*/
public static void preOrderTraveral(TreeNode node){
if(node == null){
return;
}
System.out.print(node.data+" ");
preOrderTraveral(node.leftChild);
preOrderTraveral(node.rightChild);
}
中序遍历
再者就是中序遍历,所谓的中序遍历就是先访问左节点,再访问根节点,最后访问右节点,
/**
* 二叉树中序遍历 左-> 根-> 右
* @param node 二叉树节点
*/
public static void inOrderTraveral(TreeNode node){
if(node == null){
return;
}
inOrderTraveral(node.leftChild);
System.out.print(node.data+" ");
inOrderTraveral(node.rightChild);
}
后序遍历
最后就是后序遍历,所谓的后序遍历就是先访问左节点,再访问右节点,最后访问根节点。
实现代码如下:
/**
* 二叉树后序遍历 左-> 右-> 根
* @param node 二叉树节点
*/
public static void postOrderTraveral(TreeNode node){
if(node == null){
return;
}
postOrderTraveral(node.leftChild);
postOrderTraveral(node.rightChild);
System.out.print(node.data+" ");
}
层序遍历
层序遍历,即逐层地,从左到右访问所有节点
//调用
bfs(root, 0);
List<List<Integer>> res = new ArrayList<List<Integer>>();
public void bfs(TreeNode root, int depth) {
if (res.size() == depth){
res.add(new ArrayList<Integer>());
}
//把一层上的节点存在同行数组中
res.get(depth).add(root.data);
//搜索子节点深度增1,左子节点
if (root.leftChild != null){
bfs(root.leftChild, depth + 1);
}
//搜索子节点深度增1,右子节点
if (root.rightChild != null){
bfs(root.rightChild, depth + 1);
}
}
前序遍历(非递归)
首先申请一个新的栈,记为stack; 声明一个结点treeNode,让其指向node结点; 如果treeNode的不为空,将treeNode的值打印,并将treeNode入栈,然后让treeNode指向treeNode的右结点; 重复步骤3,直到treenode为空; 然后出栈,让treeNode指向treeNode的右孩子; 重复步骤3,直到stack为空.
实现代码如下:
public static void preOrderTraveralWithStack(TreeNode node){
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode treeNode = node;
while(treeNode!=null || !stack.isEmpty()){
//迭代访问节点的左孩子,并入栈
while(treeNode != null){
System.out.print(treeNode.data+" ");
stack.push(treeNode);
treeNode = treeNode.leftChild;
}
//如果节点没有左孩子,则弹出栈顶节点,访问节点右孩子
if(!stack.isEmpty()){
treeNode = stack.pop();
treeNode = treeNode.rightChild;
}
}
}
后序遍历(非递归)
private static void postOrder(TreeNode<Integer> root) {
Stack<TreeNode> src = new Stack<TreeNode>();
Stack<TreeNode> res = new Stack<TreeNode>();
src.push(root);
while(!src.isEmpty()){
TreeNode<Integer> p = src.pop();
res.push(p);
if(p.left != null){
src.push(p.left);
}
if(p.right != null){
src.push(p.right);
}
}
//输出最终后序遍历的结果
while(!res.isEmpty()){
System.out.print(res.pop().val + " ");
}
}
计算深度
private int caculateDepth(TreeNode node) {
int leftDepth,rightDepth;
if(node == null) return 0;
else {
leftDepth = caculateDepth(node.leftChild);
rightDepth = caculateDepth(node.rightChild);
if(leftDepth >= rightDepth) {
return leftDepth+1;
}else {
return rightDepth+1;
}
}
}
二叉树最大直径
给定一棵二叉树,你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过根结点。
思路: 无论如何,一个路径一定会有一个最近的公共父结点。
路径长度 = 这个父结点的左右子树深度和
我们只需要遍历所有结点的左右子树深度和,找到最大的那个值就可以了。
深度优先遍历,设定一个成员变量,记录最大的直径。
代码实现
class Solution {
int res = 0;
public int diameterOfBinaryTree(TreeNode root) {
if(root == null) return 0;
dep(root);
return res;
}
public int dep(TreeNode node){
if(node == null) return 0;
int L = dep(node.left);
int R = dep(node.right);
res = Math.max(res, L+R);
return Math.max(L, R) +1;
}
}
关注我的公众号,学习技术或投稿
长按上图,识别图中二维码即可关注