一、树相关概念
1.节点的度:一个节点含有的子树的个数成为节点的度,节点的度为6
2.树的度:一棵树中,最大节点的度称为树的度。(同属一个父节点,叶子最多的),树的度为6
3.叶子节点或终端节点:度为0的节点称为叶子节点。叶子节点有B,C,H,I,P,Q,K,L,M,N
4.父节点或双亲节点:含有子节点的节点称为这个子节点的父节点。A为B,C,D,E,F,G的父节点
5.子节点或孩子节点:含有子树的根节点称为该节点的子节点。B为A的子节点
6.根节点:一棵树中没有双亲的节点的节点。A为根节点
7.节点的层次:根为第一层,根的子节点为第二层,以此类推。
8.树的高度或深度:深度:相对于根节点的距离,相当于每层的层数,根节点深度为1。高度:最大深度。
9.节点的祖先:从根到该节点所经分支上的所有节点。A是所有节点的祖先。
10.兄弟节点:具有相同父节点的节点。
二、二叉树
1.什么是二叉树?
每个节点最多有2个子节点,也就是说,二叉树的度最大为2。
特点:二叉树的度最大为2,其子树有左右之分,子树次序不能颠倒,因此又称二叉树为有序树。
2、两种特殊的二叉树
(1)满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是 ,则它就是满二叉树。
(2)完全二叉树: 完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
3、二叉树的性质
1.若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^(i-1) (i>0)个结点
2. 若规定只有根节点的二叉树的深度为1,则深度为K的二叉树的最大结点数是 2^k-1(k>=0)
3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0=n2+1
4. 具有n个结点的完全二叉树的深度k为log2(n+1)上取整
5. 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的顺序对所有节点从0开始编号,则对于序号为i
的结点有:
若i>0,双亲序号:(i-1)/2;i=0,i为根节点编号,无双亲节点
若2i+1<n,左孩子序号:2i+1,否则无左孩子
若2i+2<n,右孩子序号:2i+2,否则无右孩子
4、二叉树的存储
二叉树的存储有顺序存储和链式存储。
1.孩子表示法
class Node{
public char val;
public Node left;
public Node right;
public Node(char val) {
this.val = val;
}
}
2.孩子双亲表示法
class Node{
public char val;
public Node left;
public Node right;
public Node parent;
public Node(char val) {
this.val = val;
}
}
5、二叉树的基本操作
(1)二叉树的遍历:
先序遍历:先根再左再右
中序遍历:先左再根再右
后序遍历:先左再右再根
层序遍历:按层遍历
代码如下:
class Solution {
//前序遍历(递归)
List<Integer> ret1 = new ArrayList<>();
public List<Integer> preorderTraversal(TreeNode root) {
if(root == null)return ret1 ;
ret1.add(root.val);
preorderTraversal(root.left);
preorderTraversal(root.right);
return ret1;
}
//前序遍历(非递归)
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list1 = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if(root == null)return list1;
TreeNode cur = root;
while(cur != null||!stack.isEmpty()){
while(cur != null){
stack.push(cur);
list1.add(cur.val);
cur = cur.left;
}
TreeNode top = stack.pop();
cur = top.right;
}
return list1;
}
//中序遍历(递归)
List<Integer> ret2 = new ArrayList<>();
public List<Integer> inorderTraversal(TreeNode root) {
if(root == null)return ret2;
inorderTraversal(root.left);
ret2.add(root.val);
inorderTraversal(root.right);
return ret2;
}
//中序遍历(非递归)
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list2 = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if(root == null)return list2;
TreeNode cur = root;
while(cur != null||!stack.isEmpty()){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
TreeNode top = stack.pop();
list2.add(top.val);
cur = top.right;
}
return list2;
}
//后序遍历(递归)
List<Integer> ret3 = new ArrayList<>();
public List<Integer> postorderTraversal(TreeNode root) {
if(root == null)return ret3;
postorderTraversal(root.left);
postorderTraversal(root.right);
ret3.add(root.val);
return ret3;
}
//后序遍历(非递归)
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list3 = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if(root == null)return list3;
TreeNode cur = root;
TreeNode prev = null;
while(cur != null||!stack.isEmpty()){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
cur = stack.peek();
if(cur.right == null||cur.right == prev){
stack.pop();
list3.add(cur.val);
prev = cur;
cur = null;
}else{
cur = cur.right;
}
}
return list3;
}
//层序遍历
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ret4 = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
if(root == null)return ret4;
queue.offer(root);
while(!queue.isEmpty()){
List<Integer> list = new ArrayList<>();
int size = queue.size();
while(size != 0){
TreeNode cur = queue.poll();
list.add(cur.val);
if(cur.left != null){
queue.offer(cur.left);
}
if(cur.right != null){
queue.offer(cur.right);
}
size--;
}
ret4.add(list);
}
return ret4;
}
}
(2)二叉树的其他基本操作
//遍历思路 求节点数
public void getSize(Node root) {
if (root == null) return;
uSize++;
getSize(root.left);
getSize(root.right);
}
//子问题思路(左节点数+右节点数+根节点) 求节点数
public int getSize2(Node root) {
return getSize2(root.left) + getSize2(root.right) + 1;
}
//遍历思路 求叶子节点个数
public void leafSize(Node root) {
int size = 0;
if (root == null) return;
if(root.left == null&& root.right == null){
size++;
}
leafSize(root.left);
leafSize(root.right);
}
//子问题思路(左叶子数+右叶子数) 求叶子节点数
public int getLeafSize2(Node root) {
if (root == null) return 0;
if(root.left == null&& root.right == null)return 1;
return getLeafSize2(root.left) + getLeafSize2(root.right);
}
//子问题思路 求K层节点个数
public int getKLeveSize(Node root,int k){
if(root == null)return 0;
if(k == 1){
return 1;
}
return getKLeveSize(root.left,k-1) + getKLeveSize(root.right,k-1);
}
//获取二叉树的高度
public int getHeight(Node root){
if(root == null)return 0;
int leftHigh = getHeight(root.left);
int rightHigh = getHeight(root.right);
return leftHigh > rightHigh? leftHigh+1:rightHigh+1;
}
//求二叉树的高度
public int maxDepth(Node root){
if(root == null)return 0;
int l = maxDepth(root.left);
int r = maxDepth(root.right);
return l>r?l+1:r+1;
}
/**
* 查找 val 所在结点,没有找到返回 null
* 按照 根 -> 左子树 -> 右子树的顺序进行查找
* 一旦找到,立即返回,不需要继续在其他位置查找
*/
public Node Find(Node root,char val) {
if (root == null) return null;
if (root.val == val) {
return root;
}
Node r = Find(root.left, val);//访左
if (r != null) {
return r;
}
r = Find(root.left, val);//访右
if (r != null) {
return r;
}
return null;
}
/**
* 给你两棵二叉树的根节点 p 和 q ,编写一个函数来检验这两棵树是否相同。
* 如果两个树在结构上相同,并且节点具有相同的值,则认为它们是相同的。
*/
public boolean isSameTree(Node p,Node q){
if(p == null&&q == null ||p != null&&q == null||p == null&&q != null||p.val != q.val)return false;
return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
}
//判断两棵树是否完全相同
public boolean isSameTree1(Node p, Node q){
if(p == null&&q != null||p != null&&q == null||p.val != q.val)return false;
if(p == null&&q == null)return true;
return isSameTree(p.left,q.left)&& isSameTree(p.right,q.right);
}
/**
* 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠,那么将他们的值相加作为节点合并后的新值,
* 否则不为 NULL 的节点将直接作为新二叉树的节点
*/
Node beforeP = new Node();
public Node combineTree(Node p,Node q){
if(p == null)return q;
if(q == null)return p;
combineTree(p.left,q.left);
combineTree(p.right,q.right);
return p;
}