文章目录
树
在学习二叉树之前,先学习一下树的概念
树的定义:
树是一种数据结构,对比于生活中常见的树,其逻辑结构是倒立着的:
如图:
- 树是由n个节点组成的有限集,(当n==0时,称此树为空树),对于任何一棵非空树,只有唯一的根节点root.
- 当n>1时,除去根节点,剩余节点可以分为m个有限集(m>0),这些有限集互不相交,其中每个集合又是一棵树,称为根的子树。
关于树的相关概念:
树的实际实现形式(表现形式)
树结构相对于线性表比较复杂,要存储表示起来比较麻烦,有许多种表示方法,如:双亲表示法,孩子表示法,孩子双亲表示法,孩子兄弟表示法等等。
这里只介绍一下孩子兄弟表示法。
孩子兄弟表示法:
孩子兄弟表示法的思想是使得为每一个节点创建两个指针,一个指针指向此节点的第一个孩子节点
另一个指针指向此节点的兄弟节点,对于此节点的其他孩子节点则通过孩子节点的兄弟指针指向。
如图:
树的应用
我们电脑中的文件系统所采取的即树的思想:
二叉树
二叉树的概念
二叉树是一种特殊的树,与其它树不同的特性在于每一个节点最多有两个子节点。每一个节点的左树称为该节点的左子树,右树称为右子树,即:
从上图可以看出:
- 二叉树不存在度大于2的结点
- 二叉树的子树有左右之分,次序不能颠倒,因此二叉树是有序树。
特殊的二叉树
有两种特殊的二叉树,满二叉树与完全二叉树
- 满二叉树是指如果二叉树的每层节点数都达到最大值,称此二叉树为满二叉树。
如图:
- 完全二叉树是指对于一棵二叉树,其节点是根据从上到下,从左到右顺序排列的。
注:由两种特殊的二叉树性质可知,满二叉树是一种特殊的完全二叉树。
二叉树的性质:
这些二叉树的性质与算法设计紧密联系,应该熟练掌握。
- 若规定根结点的层数为1,则一棵非空二叉树的第i层上最多有 2^(i - 1)(i>0)个结点。
- 若规定只有根结点的二叉树的深度为1,则深度为K的二叉树的最大结点数是2^k-1 (k>=0)。
- 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0=n2+1。
这条性质我们需要推导一下。
- 具有N个结点的完全二叉树的深度k为log(N+1)以2为底向上取整。
解:只有完全二叉树才可以根据节点个数推导二叉树的深度,推导过程:
比如下面的这棵二叉树,log2(13+1) 取整,结果为4
- 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的顺序对所有节点从0开始编号,则 对于序号为i的结点有:
若i>0,双亲序号:(i-1)/2;i=0,i为根结点编号,无双亲结点;
若2i+1<n,左孩子序号:2i+1,否则无左孩子;
若2i+2<n,右孩子序号:2i+2,否则无右孩子。
二叉树的存储实现:
二叉树的存储实现有两种情况,一种是顺序存储(在下节堆中讲到),另一种是链式存储
二叉树的链式存储是将节点都一个个连接起来,有两个引用与三个引用的情况:
// 孩子表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用,常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用,常常代表右孩子为根的整棵右子树
}
// 孩子双亲表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用,常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用,常常代表右孩子为根的整棵右子树
Node parent; // 当前节点的双亲节点
}
二叉树的模拟实现:
实现的成员方法与属性:
public class BinaryTree {
// 前序遍历
public void preOrder(TreeNode root) {}
// 中序遍历
void inOrder(TreeNode root) {}
// 后序遍历
void postOrder(TreeNode root) {}
// 获取节点的个数
int size2(TreeNode root) {}
//获取叶子节点的个数
int getLeafNodeCount2(TreeNode root) {}
//获取第K层节点的个数
int getKLevelNodeCount(TreeNode root, int k) {}
//获取二叉树的高度 时间复杂度:O(N)
int getHeight(TreeNode root) {}
// 检测值为value的元素是否存在
TreeNode find(TreeNode root, char val) {}
//层序遍历
void levelOrder(TreeNode root) {}
// 判断一棵树是不是完全二叉树
boolean isCompleteTree(TreeNode root) {}
}
实现节点内部类:
static class TreeNode {
public char val;
public TreeNode left;//左孩子的引用
public TreeNode right;//右孩子的引用
public TreeNode(char val) {
this.val = val;
}
}
二叉树的遍历:
遍历二叉树有四种方式,分别是前序遍历,中序遍历,后序遍历,层序遍历
前序遍历是按照先根节点,然后左节点,然后右节点
中序遍历是先左节点,后根节点,然后右节点
后序遍历是先左节点,后右节点,然后根节点
二叉树不一定只有三个节点,所以这涉及递归的思想,在树的定义中,根节点的左节点即是左子树的根节点,这包含了递归的思想,所以二叉树的三种遍历可以通过递归的方式实现:
层序遍历即按照从上到下,从左到右,每一层地遍历二叉树。
前序遍历:
实现思想:遍历到当前节点时,先判断当前节点是否为空,不为空则打印此节点的数值,
并递归到本节点的左节点与右节点中去。
// 前序遍历
public void preOrder(TreeNode root) {
if (root == null) return;
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
}
中序遍历:
实现思想:遍历到当前节点时,判断当前节点是否为空,不为空,则先递归到当前节点的左节点中去,从左节点的方法返回时,再打印当前节点,然后再递归到右节点中去。
// 中序遍历
void inOrder(TreeNode root) {
if (root == null) return;
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
后序遍历
实现思想:遍历到当前节点时,判断当前节点是否为空,不为空,则先递归到当前节点的左节点中去,从左节点的方法返回时,再递归到右节点中去,当从左节点的方法与右节点的方法返回时,打印
根节点数值。
// 后序遍历
void postOrder(TreeNode root) {
if (root == null) return;
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
}
层序遍历:
问题: 如何找到当前节点的兄弟节点,并且能够返回到当前层的第一个节点的左节点,递归的思想实现不了,我们需要一个新的数据结构,能够储存节点。
实现思想:
进行层序遍历时,我们要用到队列(先进先出)这个数据结构,
从根结点开始先放进队列去。
然后将队列中节点取出打印,如果此节点的左右节点不为空,则将左右节点放入队列中,然后再循环往复,直到队列为空为止。
//层序遍历
void levelOrder(TreeNode root) {
if (root == null) return;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
System.out.print(cur.val + " ");
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
}
获取节点的个数
实现思想:采用递归的思想,左子树节点个数+右子树节点个数+1,如果此节点为空,返回0.
int size2(TreeNode root) {
if (root == null) return 0;
return size2(root.left)
+ size2(root.right) + 1;
}
获取叶子节点的个数
获取叶子节点的个数
实现思想:
采用递归的思想
如果树为空,返回0。
不为空,如果节点左子树和右子树为空则返回1。
最后返回根节点左子树和右子树的叶子结点之和。
int getLeafNodeCount2(TreeNode root) {
if (root == null) return 0;
if (root.left == null && root.right == null) {
return 1;
}
return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
}
获取第k层节点的个数
思想:获取二叉树第k层的节点相当于获取其子树的k-1层节点,以此递归直至k=1.
实现思想:
- 如果树为空,返回0。
- 不为空,如果层数为1并且该节点不为空则返回1。(如果k为1,且此节点存在,则此树的节点即此节点为1)
- 最后返回根节点左子树和右子树的第k-1层结点之和。
int getKLevelNodeCount(TreeNode root, int k) {
if (root == null) return 0;
if (k == 1) return 1;
return getKLevelNodeCount(root.left, k - 1) +
getKLevelNodeCount(root.right, k - 1);
}
获取二叉树的高度
实现思想:通过递归思想,获取左子树高度与右子树高度,取两者最大值然后+1
int getHeight(TreeNode root) {
if (root == null) return 0;
int leftH = getHeight(root.left);
int rightH = getHeight(root.right);
return leftH > rightH ? leftH + 1 : rightH + 1;
}
检查值为value的元素是否存在
public TreeNode contains(TreeNode root , int val){
//采用前序遍历
if(root == null){
return null;
}
if(root.val == val){
return root;
}
TreeNode b1 = contains(root.left);
if(b1!=null){
return b1;
}
TreeNode b2 = contains(root.right);
if(b2!=null){
return b2;
}
return null;
}
判断一棵树是否是完全二叉树
实现思想:
在之前层序遍历的实现算法中,我们采用了一个新的数据结构,将每一个节点的非空子节点存储至队列中,对于判断完全二叉树,也可以通过一个队列,将遍历到的节点的左节点与右节点均放入队列中,无论其是否为空节点,然后将队列中的全部数据输出,如果发现空节点之后,还有数据说明此树非完全二叉树,没有,则说明此树为完全二叉树。
具体实现思想:
- 如果根节点为空直接返回false。
- 不为空将根放入队列。
- 取出队列值,如果值不为空就将左孩子和右孩子(孩子是否为空不影响入队)入队,为空直接出循环。
- 因为前面是拿到队列中的空节点出循环的,遍历剩余节点如果遇到不为空的节点那该树就不是完全二叉树。
boolean isCompleteTree(TreeNode root) {
if (root == null) return false;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
if (cur != null) {
queue.offer(cur.left);
queue.offer(cur.right);
} else {
break;
}
}
//第2次遍历队列 判断队列当中 是否存在非空的元素
while(!queue.isEmpty()) {
TreeNode cur = queue.peek();
if (cur == null) {
queue.poll();
} else {
return false;
}
}
return true;
}
}
二叉树相关的oj题
相同的树
实现思想:采用递归的思想,判断左子树与左子树相同,右子树与右子树相同,两个根节点也相同。
class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p ==null&&q==null){
return true;
}
//此时设计判断条件是为了下一条件避免空指针异常
if((p !=null && q== null)||(p==null&&q!=null)){
return false;
}
if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
return true;
}
return false;
}
}
判断本树是否包含与另一棵树相同的子树
实现思想:遍历本树的每一个节点,然后以当前节点作为根节点判断与另一棵树是否相同
需要创建两个方法。一个用于遍历,一个用于比较。
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//遍历整个二叉树,按照前序遍历的方式
if(root == null){
return false;
}
boolean b1 = isSameTree(root,subRoot);
if(b1 ==true){
return true;
}
boolean b2 = isSubtree(root.left,subRoot);
if(b2 == true){
return true;
}
boolean b3 = isSubtree(root.right,subRoot);
if(b3 ==true){
return true;
}
return false;
}
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p ==null&&q==null){
return true;
}
//此时设计判断条件是为了下一条件避免空指针异常
if((p !=null && q== null)||(p==null&&q!=null)){
return false;
}
if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
return true;
}
return false;
}
}
翻转二叉树
实现思想:采用递归的思想,将每一个节点的左节点与右节点相互交换
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null){
return null;
}
TreeNode cur = root.left;
root.left = root.right;
root.right = cur;
//将左子树与右子树,依次翻转
invertTree(root.left);
invertTree(root.right);
return root;
}
}
判断一棵二叉树是否是平衡二叉树
实现思想:在获取二叉树的高度的方法中,获取每一个节点的左子树高度与右子树高度之差,如果绝对值中出现大于的情况,返回-1 。
class Solution {
public boolean isBalanced(TreeNode root) {
return isBalanced2(root)!=-1;
}
public int isBalanced2(TreeNode root){
if(root == null){
return 0;
}
int leftHeight = isBalanced2(root.left);
if(leftHeight == -1){
return -1;
}
int rightHeight = isBalanced2(root.right);
if(rightHeight == -1){
return -1;
}
if(Math.abs(leftHeight-rightHeight)>1){
return -1;
}
return leftHeight>rightHeight ? leftHeight+1:rightHeight+1;
}
}
对称二叉树
实现思想:通过递归的思想,判断根节点的左节点的左子树与右节点的右子树,左节点的右子树与右节点的左子树是否相同。
class Solution {
public boolean isSymmetric(TreeNode root) {
return isSymmetric2(root.left,root.right);
}
public boolean isSymmetric2(TreeNode r1 , TreeNode r2){
if(r1 == null&&r2 == null){
return true;
}
if( ( r1!= null&&r2 ==null)|| (r1==null&&r2!=null) ){
return false;
}
if(r1.val ==r2.val&& isSymmetric2(r1.left,r2.right)&&isSymmetric2(r1.right,r2.left)){
return true ;
}
return false;
}
}
二叉树的构建与遍历
实现思想:通过递归算法,按照前序遍历的顺序进行节点创建并赋值,如果遇到#则跳过。
import java.util.Scanner;
class TreeNode {
public TreeNode left;
public TreeNode right;
public char val;
public TreeNode(char val) {
this.val = val;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextLine()) { // 注意 while 处理多个 case
String str = in.nextLine();
TreeNode cur = createtree(str);
inOrder(cur);
}
}
public static int i;
public static TreeNode createtree(String str) {
//开始创建
TreeNode root = null;
if (str.charAt(i) != '#') {
root = new TreeNode(str.charAt(i));
i++;
root.left = createtree(str);
root.right = createtree(str);
} else {
i++;
}
return root;
}
public static void inOrder(TreeNode root) {
if (root == null) {
return;
}
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
}
二叉树的分层遍历
实现思想:在之前的层序遍历中,我们是将在将每一个节点从队列中出去时,并将此节点的非空子节点输入到队列中,但是在本题中我们需要区分每一层之间的节点
- 所以在输入完一层的节点后,我们需要先判断当前队列中的节点数量
- 然后以此作为判断条件循环将当前队列中的值,输入到一个新的数组中去,并且将每一个节点的非空子节点输入到队列中去,将新的数组输入到二维数组中去。
- 循环往复,直到队列为空。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list1 = new ArrayList<>();
if(root == null){
return list1;
}
LinkedList <TreeNode> queue = new LinkedList(); //创建队列
queue.offer(root);
while (!queue.isEmpty()) {
//打印队列中的节点
//先获取队列中上一层节点的个数
int len = queue.size();
List<Integer>list2 = new ArrayList<>();
while(len>=1){
//将队列1中队出的数据存入队列2中
TreeNode cur = queue.poll();
list2.add(cur.val);
//然后将本节点左节点与右节点放入队列1中
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
//最后将当前数组中的内容加入到二维数组中去
len--;
}
list1.add(list2);
}
return list1;
}
}