leetcode-二叉树
树以及常用的算法
树的概念
树(Tree)的基本概念
树是由结点或顶点和边组成的(可能是非线性的)且不存在着任何环的一种数据结构。没有结点的树称为空(null或empty)树。一棵非空的树包括一个根结点,还(很可能)有多个附加结点,所有结点构成一个多级分层结构。
二叉树的概念
每个结点至多拥有两棵子树(即二叉树中不存在度大于2的结点),并且,二叉树的子树有左右之分,其次序不能任意颠倒。
二叉树的性质
1.若二叉树的层次从0开始,则在二叉树的第i层至多有2^i个结点(i>=0)
2.高度为k的二叉树最多有2^(k+1) - 1个结点(k>=-1)(空树的高度为-1)
3.对任何一棵二叉树,如果其叶子结点(度为0)数为m, 度为2的结点数为n, 则m = n + 1
二叉树的分类
二叉树又分为:完美二叉树,完全二叉树,完满二叉树
其中完满二叉树:除了叶子节点每个节点都有俩个孩子
完全二叉树:除了最后一层外,除了叶子节点每个节点都有俩个孩子
完美二叉树:除了叶子节点外,每一层每个节点都有俩个孩子
完美二叉树
完全二叉树
完满二叉树
完满二叉树
二叉树常见的搜索算法,借助leetcode展示
前序遍历
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* Given a binary tree, return the preorder traversal of its TreeNodes' values.
*/
public class Lc144 {
/*
* 前序遍历 :根左右 思路;将当前节点压入栈中,一直遍历左子树知道当前节点为空,向上弹出遍历一下右子树。
*/
public static List<Integer> preorderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
TreeNode curr = root;
while (curr != null || !stack.isEmpty()) {
while (curr != null) {
list.add(curr.val);
stack.push(curr);
curr = curr.left;
}
curr = stack.pop();
curr = curr.right;
}
return list;
}
public static void main(String[] args) {
Integer[] arr = new Integer[] { 1, 2, null};
TreeNode root = CreateNode.createTree(arr).get(0);
List<Integer> list = preorderTraversal(root);
list.forEach(n -> System.out.println(n));
}
}
中顺遍历
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* Given a binary tree, return the inorder traversal of its nodes' values.
*/
public class Lc94 {
/*
* 中序遍历:左根右
*/
public static List<Integer> orderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
List<Integer> preorder = new ArrayList<Integer>();
TreeNode curr = root;
while (!stack.isEmpty() || curr != null) {
while (curr != null) {
stack.push(curr);
curr = curr.left;
}
curr = stack.pop();
preorder.add(curr.val);
curr = curr.right;
}
return preorder;
}
public static void main(String[] args) {
Integer[] arr = new Integer[] { 1, null, 2, null, null, 3 };
TreeNode root = CreateNode.createTree(arr).get(0);
List<Integer> list = orderTraversal(root);
list.forEach(n -> System.out.println(n));
}
}
后序遍历
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Lc145 {
/*
* 后续序遍历:左右根
*/
public static List<Integer> postorderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
if (root == null) {
return list;
}
TreeNode curr = root;
stack.push(curr);
while (!stack.isEmpty()) {
curr = stack.pop();
list.add(0, curr.val);
if (curr.left != null) {
stack.push(curr.left);
}
if (curr.right != null) {
stack.push(curr.right);
}
}
return list;
}
public static void main(String[] args) {
Integer[] arr = new Integer[] { 1, null, 2 };
TreeNode root = CreateNode.createTree(arr).get(0);
List<Integer> list = postorderTraversal(root);
list.forEach(n -> System.out.println(n));
}
}
层序遍历
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Lc102 {
/**
* 层序遍历
*
* @param root
* @return
*/
public static List<List<Integer>> levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
List<List<Integer>> lists = new ArrayList<List<Integer>>();
List<Integer> list = new ArrayList<>();
if (root == null) {
return lists;
}
TreeNode curr = root;
queue.offer(curr);
int size = queue.size();
while (!queue.isEmpty()) {
curr = queue.poll();
list.add(curr.val);
size--;
if (curr.left != null) {
queue.offer(curr.left);
}
if (curr.right != null) {
queue.offer(curr.right);
}
if (size == 0) {
lists.add(list);
list = new ArrayList<>();
size = queue.size();
}
}
return lists;
}
public static void main(String[] args) {
Integer[] arr = new Integer[] { 1, 2, 3, 4, 5, 6, 7 };
TreeNode root = CreateNode.createTree(arr).get(0);
List<List<Integer>> lists = levelOrder(root);
lists.forEach(n -> {
n.forEach(m -> {
System.out.print(m + ",");
});
System.out.println();
});
}
}
BFS
public class Lc100 {
//bfs 递归
public static boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null || q == null) {
return p == q ? true : false;
} else {
if (p.val != q.val) {
return false;
} else {
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
}
}
public static void main(String[] args) {
Integer[] arr = new Integer[] { 1, 2, 2, 3, null, null, 3 };
TreeNode root = CreateNode.createTree(arr).get(0);
System.out.println(isSameTree(root.left, root.right));
}
}
介绍一个二叉树数组转换节点的工具类
使用方法,每一个main函数中都是
import java.util.ArrayList;
import java.util.List;
public class CreateNode {
public static List<TreeNode> list = new ArrayList<TreeNode>(); // 用一个集合来存放每一个Node
public static List<TreeNode> createTree(Integer[] array) {
list.clear();
for (int i = 0; i < array.length; i++) {
TreeNode TreeNode = new TreeNode(array[i], null, null); // 创建结点,每一个结点的左结点和右结点为null
list.add(TreeNode); // list中存着每一个结点
}
// 构建二叉树
if (list.size() > 0) {
for (int i = 0; i < array.length / 2 - 1; i++) { // i表示的是根节点的索引,从0开始
if (list.get(2 * i + 1) != null) {
// 左结点
list.get(i).left = list.get(2 * i + 1);
}
if (list.get(2 * i + 2) != null) {
// 右结点
list.get(i).right = list.get(2 * i + 2);
}
}
// 判断最后一个根结点:因为最后一个根结点可能没有右结点,所以单独拿出来处理
int lastIndex = array.length / 2 - 1;
// 左结点
list.get(lastIndex).left = list.get(lastIndex * 2 + 1);
// 右结点,如果数组的长度为奇数才有右结点
if (array.length % 2 == 1) {
list.get(lastIndex).right = list.get(lastIndex * 2 + 2);
}
}
return list;
}
// 遍历,先序遍历
public static void print(TreeNode TreeNode) {
if (TreeNode != null) {
System.out.print(TreeNode.val + " ");
print(TreeNode.left);
print(TreeNode.right);
}
}
/**
* @param args
*/
public static void main(String[] args) {
Integer[] array = { 1, 2, 2, null, 3, null, 3 };
CreateNode.createTree(array);
print(list.get(0));
}
}
基础类-节点
public class TreeNode {
public Integer val; // 自己本身值
public TreeNode left; // 左结点
public TreeNode right; // 右结点
public TreeNode() {
}
public TreeNode(Integer val, TreeNode left, TreeNode right) {
super();
this.val = val;
this.left = left;
this.right = right;
}
public int getVal() {
return val;
}
public void setVal(Integer val) {
this.val = val;
}
public TreeNode getLeft() {
return left;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public TreeNode getRight() {
return right;
}
public void setRight(TreeNode right) {
this.right = right;
}
}
leetcode-二叉树的更多相关文章
- LeetCode二叉树实现
LeetCode二叉树实现 # 定义二叉树 class TreeNode: def __init__(self, x): self.val = x self.left = None self.righ ...
- LeetCode 二叉树,两个子节点的最近的公共父节点
LeetCode 二叉树,两个子节点的最近的公共父节点 二叉树 Lowest Common Ancestor of a Binary Tree 二叉树的最近公共父亲节点 https://leetcod ...
- leetcode二叉树题目总结
leetcode二叉树题目总结 题目链接:https://leetcode-cn.com/leetbook/detail/data-structure-binary-tree/ 前序遍历(NLR) p ...
- [LeetCode] 二叉树相关题目(不完全)
最近在做LeetCode上面有关二叉树的题目,这篇博客仅用来记录这些题目的代码. 二叉树的题目,一般都是利用递归来解决的,因此这一类题目对理解递归很有帮助. 1.Symmetric Tree(http ...
- LeetCode二叉树的前序、中序、后序遍历(递归实现)
本文用递归算法实现二叉树的前序.中序和后序遍历,提供Java版的基本模板,在模板上稍作修改,即可解决LeetCode144. Binary Tree Preorder Traversal(二叉树前序遍 ...
- LeetCode 二叉树的层次遍历
第102题 给定一个二叉树,返回其按层次遍历的节点值. (即逐层地,从左到右访问所有节点). 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 ...
- LeetCode 二叉树的锯齿形层次遍历
第103题 给定一个二叉树,返回其节点值的锯齿形层次遍历.(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行). 例如: 给定二叉树 [3,9,20,null,null,15,7] ...
- Leetcode——二叉树常考算法整理
二叉树常考算法整理 希望通过写下来自己学习历程的方式帮助自己加深对知识的理解,也帮助其他人更好地学习,少走弯路.也欢迎大家来给我的Github的Leetcode算法项目点star呀~~ 二叉树常考算法 ...
- LeetCode 二叉树的最小深度
计算二叉树的最小深度.最小深度定义为从root到叶子节点的最小路径. public class Solution { public int run(TreeNode root) { if(root = ...
- LeetCode - 二叉树的最大深度
自己解法,欢迎拍砖 给定一个二叉树,找出其最大深度. 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数. 说明: 叶子节点是指没有子节点的节点. 示例:给定二叉树 [3,9,20,null,nu ...
随机推荐
- Vue项目中实现用户登录及token验证
学习博客:https://www.cnblogs.com/web-record/p/9876916.html
- skipping archived logs of thread 1 from sequence 29 to 46; already backed up
问题描述:删除归档的备份,在进行归档的重新备份,提示:skipping archived logs of thread 1 from sequence 29 to 46; already backed ...
- Spring Cloud第九篇 | 分布式服务跟踪Sleuth
本文是Spring Cloud专栏的第九篇文章,了解前八篇文章内容有助于更好的理解本文: Spring Cloud第一篇 | Spring Cloud前言及其常用组件介绍概览 Spring Cl ...
- django----session相关配置
1. 数据库Session SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎(默认) 2. 缓存Session SESSION_E ...
- webpack学习1.1 webpack背景介绍
一.为什么要前端需要构建? 开发复杂化 框架去中心化(代码中需要的模块都可以通过npm安装佢解决一个问题,包越来越零散,根据需要来安装) 开发编译化 语言模块化 二.为什么要用webpack? 1.三 ...
- CSS | 圣杯布局、双飞翼布局 | 自适应三栏布局
圣杯布局和双飞翼布局是前端工程师需要日常掌握的重要布局方式.两者的功能相同,都是为了实现一个两侧宽度固定,中间宽度自适应的三栏布局 虽然两者的实现方法略有差异,不过都遵循了以下要点: 1.两侧宽度固定 ...
- 《Java练习题》进阶练习题(三)
编程合集: https://www.cnblogs.com/jssj/p/12002760.html 前言:不仅仅要实现,更要提升性能,精益求精,用尽量少的时间复杂度和空间复杂度解决问题. [程序68 ...
- 《CSAPP》实验一:位操作
<CSAPP>号称程序员圣经,虽然中文译名为<深入理解计算机系统>,但其实没那么"深",只是覆盖面很广,一般用作计算机专业大一导论课的教科书.早就听闻书上配 ...
- SpringCloud-使用熔断器仪表盘监控熔断
场景 SpringCloud-使用熔断器防止服务雪崩-Ribbon和Feign方式(附代码下载): https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/ ...
- 开源WAF工具ModSecurity
0 前言 ModSecurity是一个开源的跨平台Web应用程序防火墙(WAF)引擎,用于Apache,IIS和Nginx,由Trustwave的SpiderLabs开发.作为WAF产品,ModSec ...