二叉树记录
关键词解释:
节点的度 :
一个节点拥有的子节点个数被称为该节点的度
树的度 :
一颗树中,所有节点中最大的度被称为树的度
叶子节点/终端节点
度为0的节点被称为叶节点,也就是最底下的节点
分支节点或非终端节点
度不为0的节点.
兄弟节点
具有相同父节点的节点互称为兄弟节点
堂兄弟节点
双亲在同一层的节点 H J 就是堂兄弟节点
树的深度和高度
深度:从上往下
高度,从下往上
树中节点最大层次
树的形式:
有双亲表示法,孩子表示法,还孩子兄弟表示法
孩子兄弟表示法
class Node {
int value;
Node firstChild;
Node nextBrother;
}
二叉树的性质
二叉树的特点
- 每个节点最多有两个子节点,即二叉树所有节点的度都不大于
- 二叉树的子树有左右之分,子树的次序不能颠倒,因此二叉树是有序树.
图中是二叉树的5种基本形态:
从左到右依次是,空树,只有根节点的二叉树,只有左子树的节点,只有右子树的节点,左右子树都存在的节点.
一般二叉树都是由上述5中基本形态组合而成的.
特殊的二叉树
- 满二叉树
一个二叉树,如果每一层的节点都达到最大值,则这个二叉树就是满二叉树.也就是说,如果一个二叉树的层数为K,且节点总数是 2^K -1.那么它就是满二叉树 - 完全二叉树
对于深度为K,有n个节点的二叉树,当且晋档每一个节点都与深度为K的满二叉树中编号为1到N的节点一一完全对应的时候被称为完全二叉树,满二叉树也被算为一种完全二叉树.
数字性质
- 如果规定根节点的层数为1,则,一个非空二叉树的第K层最多有 2^(K-1) 个节点 (i>1).
- 若规定只有根节点的二叉树深度为1,则深度为K的二叉树最大节点数为 (2^K) -1
- 对任何一个二叉树老说,如果其叶节点个数为 n0,度为2的非叶节点个数为 n2 则有n0 = n2 +1
- 具有n个节点的完全二叉树的深度K 为 log2(n+1)向上取整.
遍历形式
1. 先序遍历
诸如根左右的顺序遍历
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
2. 中序遍历
诸如左根右的形式
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
把树投影下来就是中序遍历的顺序
3. 后序遍历
诸如左右根的形式
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
4. 层序遍历
通过队列,先将头节点存入,如果队列不为空输出当前节点的值,当前节点的左节点和右节点不为空就依次存入队列,接着删除当前结点,以此循环.
Queue<Node> queue = new LinkedList<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()){
System.out.println(queue.element().val);
if(queue.element().left != null){
queue.offer(queue.element().left);
}
if(queue.element().right != null){
queue.offer(queue.element().right);
}
queue.remove();
}
给定前序 中序,或者中序后序进行还原二叉树.
二叉树的实现:
package 课堂代码.数据结构.课件练习.二叉树;
import 寒假作业.day01.练习.B;
class Node {
String val;
Node left;
Node right;
public Node(String val) {
this.val = val;
}
}
public class BinaryTree {
//和类一起加载了
public static Node build() {
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
Node d = new Node("D");
Node e = new Node("E");
Node f = new Node("F");
Node g = new Node("G");
a.left = b;
a.right = c;
b.left = d;
b.right = e;
e.left = g;
c.right = f;
return a;
}
//先序遍历
public static void preOrder(Node root) {
if (root == null) {
return;
}
System.out.print(root.val + " ");
preOrder(root.left);
preOrder(root.right);
}
//中序遍历
public static void inOrder(Node root) {
if (root == null) {
return;
}
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
//后序遍历
public static void postOrder(Node root) {
if (root == null) {
return;
}
postOrder(root.left);
postOrder(root.right);
System.out.print(root.val + " ");
}
//使用成员变量求树的元素个数
public static int count = 0;
public static void length(Node root) {
if (root == null) {
return;
}
count++;
length(root.left);
length(root.right);
}
//递归求树的元素个数
public static int length2(Node root) {
if (root == null) {
return 0;
}
return 1 + length2(root.left) + length2(root.right);
}
//求有多少个叶子结点
public static int leafSize = 0;
public static void getLeafSize(Node root) {
if (root == null) {
return;
}
if (root.left == null && root.right == null) {
leafSize++;
}
getLeafSize(root.left);
getLeafSize(root.right);
}
//递归求叶子结点个数
public static 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);
}
//递归求某一层节点个数
public static int getKLevelSize(Node root, int k) {
if (root == null) {
return 0;
}
if (root != null && k == 1) {
return 1;
}
return getKLevelSize(root.left, k - 1) + getKLevelSize(root.right, k - 1);
}
//递归求树的深度
public static int getHeight(Node root) {
if (root == null) {
return 0;
}
int left = getHeight(root.left);
int right = getHeight(root.right);
return 1 + (left > right ? left : right);
}
//查找根据字段返回节点地址
public static Node find(Node root, String toFind) {
if (root == null) {
return null;
}
if (root.val == toFind) {
return root;
}
Node nodeleft = find(root.left, toFind);
if (nodeleft != null) {
return nodeleft;
} else {
return find(root.right, toFind);
}
}
public static void main(String[] args) {
Node root = BinaryTree.build();
// BinaryTree.preOrder(root);
// System.out.println("\n=======================");
// BinaryTree.inOrder(root);
// System.out.println("\n=======================");
// BinaryTree.postOrder(root);
// BinaryTree.length(root);
// System.out.println(count);
// System.out.println(BinaryTree.length2(root));
// BinaryTree.getLeafSize(root);
// System.out.println(leafSize);
// System.out.println(BinaryTree.getLeafSize2(root));
// System.out.println(BinaryTree.getKLevelSize(root, 4));
// System.out.println(BinaryTree.getHeight(root));
System.out.println(BinaryTree.find(root,"D"));
}
}