一、 树的概述
树是计算机中应用广泛的一种数据结构，日常生活中常见的图谱，公司组织结构等，都是树结构的数据。
树结构在计算机中是根朝上，叶子结点向下的。如图，它是由N个有限结点组成的具有层次关系的集合。
树有如下特点：
- 没有父结点的称为根结点
- 每个结点有0或多个子结点
- 每一个非根结点只有一个父结点
- 每个结点及其后代结点可以看成一颗子树，称为当前结点父结点的一颗子树
二、 树的术语
- 结点的度：结点所含子树的个数称为结点的度，如下图：2,3,4为1的子树，1的度为3。5,8和6为2的子树，2的度为2。
- 叶结点：度为0的结点称为叶结点，如4即为叶结点
- 分支结点：度不为0的结点称为分支结点。
- 结点的层次：根结点层次为1，往下的后继结点层次为2，依次类推
- 结点的层序编号：将结点的元素，从上到下，从左到右依次排序，如下图为12345678
- 树的度：树中所有结点的度的最大值，不一定是根结点，如下截图的6若衍生很多的子结点，则度的最大值计算应该算6的子结点个数
- 树的深度：层次最多的结点
- 森林：去掉根结点后的N个不相交的集合，称为森林
- 孩子结点：一个结点的后继结点称为孩子结点
- 父结点：一个结点的前驱结点称为父结点
- 兄弟结点：同一父结点的孩子结点互称为兄弟结点
三、 二叉树的基本定义
二叉树：度不超过2的数称为二叉树
满二叉树：每一个结点度都达到最大值的树称为满二叉树
完全二叉树：往二叉树放元素时，按从上到下，从左到右的次序去放，即度为0的叶子结点，只能出现在最下或次下层的称为完全二叉树
四、 二叉查找树的构建
构建如上图的二叉树，需要怎样声明对象和组成二叉树呢，见如下实现：
public class Node<Key,Value> {
//结点的键
public Key key;
//结点的值
public Value value;
//结点的左子结点
public Node left;
//结点的右子结点
public Node right;
public Node(Key key, Value value, Node left, Node right) {
super();
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
public static void main(String[] args) {
Node node1 = new Node(1, "A", null, null);
Node node2 = new Node(2, "B", null, null);
Node node3 = new Node(3, "C", null, null);
Node node4 = new Node(4, "D", null, null);
Node node5 = new Node(5, "E", null, null);
Node node6 = new Node(6, "F", null, null);
node1.left = node2;
node1.right = node3;
node2.left = node4;
node2.right = node5;
node3.left = node6;
}
}
|
五、 二叉查找树的实现
二叉树插入键值对：
（1） 当前二叉树的结点为空时，把新结点作为根结点
（2） 当前二叉树的结点不为空时，若新结点的key小于当前结点，则继续查找当前结点的左子结点
（3） 若新结点的key大于当前结点，则继续查找当前结点的右子结点
（4） 若新结点的key等于当前结点，则将当前结点的value替换
二叉树获取指定结点：
（1） 从根结点开始，若查询的key小于当前结点，则继续查找当前结点的左子结点
（2） 若查询的key大于当前结点，则继续查找当前结点的右子结点
（3） 若查询的key等于当前结点，则返回当前结点
二叉树删除指定结点：
（1） 首先使用获取结点的方法，找到要删除的结点
（2） 找到被删除结点右子树中最小的元素min，并删除它
（3） 让被删除结点的左子树成为min的左子树，让被删除结点的右子树成为min的右子树
（4） 让被删除结点的父节点指向min
public class BinaryTree<Key extends Comparable<Key>,Value> {
// 根结点声明
public Node root;
//树的元素个数
public int N;
public BinaryTree() {
root = null;
N=0;
}
/**
* 二叉树元素个数
* @return
*/
public int size() {
return N;
}
/**
* 二叉树是否为空
* @return
*/
public boolean isEmpty() {
return N==0;
}
/**
* 往二叉树中添加元素
* @param key
* @param value
*/
public void put(Key key,Value value) {
root = put(root, key, value);
}
/**
* 往二叉树指定结点添加元素
* @param node
* @param key
* @param value
*/
public Node put(Node node,Key key,Value value) {
if(node==null) {
//总数+1
N++;
return new Node(key, value, null, null);
}
int compare = key.compareTo((Key) node.key);
if(compare>0) {
//存放的key大于当前结点，则继续遍历当前结点的右子树
node.right = put(node.right,key,value);
}else if(compare<0) {
//存放的key小于当前结点，则继续遍历当前结点的左子树
node.left = put(node.left,key,value);
}else {
//存放的key等于当前结点，则替换
node.value = value;
}
return node;
}
/**
* 从二叉树中获取key对应的value
* @param key
* @return
*/
public Value get(Key key) {
return get(root,key);
}
/**
* 从二叉树指定结点中获取key对应的value
* @param node
* @param key
* @return
*/
public Value get(Node node,Key key) {
if(node==null) {
return null;
}
int compare = key.compareTo((Key) node.key);
if(compare>0) {
//查找的key大于当前结点，则继续遍历当前结点的右子树
return get(node.right,key);
}else if(compare<0) {
//查找的key小于当前结点，则继续遍历当前结点的左子树
return get(node.left,key);
}else{
return (Value) node.value;
}
}
/**
* 删除二叉树中指定结点
* @param key
*/
public Node delete(Key key) {
return delete(root,key);
}
/**
* 删除二叉树中指定结点
* @param node
* @param key
*/
public Node delete(Node node,Key key) {
if(node==null) {
return null;
}
int compare = key.compareTo((Key) node.key);
if(compare>0) {
//删除的key大于当前结点，则继续遍历当前结点的右子树，
node.right = delete(node.right,key);
}else if(compare<0) {
//删除的key大于当前结点，则继续遍历当前结点的右子树，
node.left = delete(node.left,key);
}else {
//被删除结点只有左结点，没有右结点的情况
if(node.left!=null && node.right == null) {
//总数减1
N--;
return node.left;
}
//被删除结点只有右结点，没有左节点的情况
if(node.right!=null && node.left == null) {
//总数减1
N--;
return node.right;
}
//找到被删除结点的右子树中的最小结点，用来取代被删除的结点
Node min = node.right;
while(min.left!=null) {
min = min.left;
}
//删除被删除结点的右子树中的最小结点
Node delNode = node.right;
while(delNode.left !=null) {
if(delNode.left.left==null) {
delNode.left = null;
}else {
delNode = delNode.left;
}
}
//让被删除结点右子树中的最小结点，取代被删除的结点
min.right = node.right;
min.left = node.left;
node = min;
//总数减1
N--;
}
return node;
}
}
|
六、 二叉查找树最小键
查找二叉树中最小键的思路：从根结点找起，一直找当前结点的左子树，直到当前结点的左子树为空时，则当前结点为二叉查找树的的最小键
/**
* 查找二叉查找树的最小键
* @return
*/
public Key min() {
return (Key) min(root).key;
}
public Node min(Node node) {
if(node.left!=null) {
return min(node.left);
}else {
return node;
}
}
|
七、 二叉查找树最大键
查找二叉树中最大键的思路：从根结点找起，一直找当前结点的右子树，直到当前结点的右子树为空时，则当前结点为二叉查找树的的最大键
/**
* 查找二叉查找树的最大键
* @return
*/
public Key max() {
return (Key) max(root).key;
}
public Node max(Node node) {
if(node.right!=null) {
return max(node.right);
}else {
return node;
}
}
|
八、 二叉树的最大深度
计算二叉树最大深度的思路
- 当只有一个根结点时为1，当根结点为null时是0
- 计算左子树的最大深度
- 计算右子树的最大深度
- 比较左右子树最大深度，取较大值+1（根结点）
/**
* 查找二叉树的最大深度
* @return
*/
public int deepLength() {
return deepLength(root);
}
public int deepLength(Node node) {
//根结点为空
if(node==null) {
return 0;
}
//根结点不为空，定义左结点深度maxLeft,右结点深度maxRight，最大深度等于maxLeft和maxRight的较大值+1
int maxLeft = 0;
int maxRight = 0;
int max = 0;
System.out.println(node.key);
//右子树不为空，则持续遍历当前结点的右子树
if(node.right!=null) {
maxRight = deepLength(node.right);
}
//左子树不为空，则持续遍历当前结点的左子树
if(node.left!=null) {
maxLeft = deepLength(node.left);
}
//最大深度计算
max = maxLeft > maxRight ? maxLeft+1 : maxRight+1;
return max;
}
|
九、 二叉树的遍历
如线性表中的链表，数组，队列，栈一样，二叉树也有遍历查找的需求，由于树的结构和线性表有很大的差异，没有办法从前往后去查询，此时我们可以根据搜索路径来查找，即通过控制根结点
左子树或右子树的访问顺序，来实现二叉树的遍历查询。
- 前序遍历：先访问根结点，再访问左子树，后访问右子树
- 中序遍历：先访问左子树，再访问根结点，后访问右子树
- 后序遍历：先遍历左子树，再访问右子树，后访问根结点
前序遍历结果：EBADCGFH
中序遍历结果：ABCDEFGH
后序遍历结果：ACDBFHGE
十、 二叉树的遍历-前序遍历
前序遍历的实现思路
- 将当前结点的key放入队列中
- 遍历当前结点的左子树，左子树不为空时，递归遍历左子树
- 遍历当前结点的右子树，右子树不为空时，递归遍历右子树
/**
* 前序遍历实现
*/
public Queue<Key> preSearch() {
Queue<Key> keys = new Queue<Key>();
preSearch(root, keys);
return keys;
}
public void preSearch(Node node, Queue<Key> keys) {
if (node == null) {
return;
}
// 将当前结点放入队列中
keys.enqueue((Key) node.key);
// 遍历左子树，不为空时递归遍历
if (node.left != null) {
preSearch(node.left, keys);
}
// 遍历右子树，不为空时递归遍历
if (node.right != null) {
preSearch(node.right, keys);
}
}
|
十一、 二叉树的遍历-后序遍历
后序遍历的实现思路
- 遍历当前结点的左子树，左子树不为空时，递归遍历左子树
- 遍历当前结点的右子树，右子树不为空时，递归遍历右子树
- 将当前结点的key放入队列中
/**
* 后序遍历实现
*/
public Queue<Key> afterSearch() {
Queue<Key> keys = new Queue<Key>();
afterSearch(root, keys);
return keys;
}
public void afterSearch(Node node, Queue<Key> keys) {
if (node == null) {
return;
}
// 遍历左子树，不为空时递归遍历
if (node.left != null) {
afterSearch(node.left, keys);
}
// 遍历右子树，不为空时递归遍历
if (node.right != null) {
afterSearch(node.right, keys);
}
// 将当前结点放入队列中
keys.enqueue((Key) node.key);
}
|
十二、 二叉树的遍历-中序遍历
中序遍历的实现思路
- 遍历当前结点的左子树，左子树不为空时，递归遍历左子树
- 将当前结点的key放入队列中
- 遍历当前结点的右子树，右子树不为空时，递归遍历右子树
/**
* 中序遍历实现
*/
public Queue<Key> midSearch() {
Queue<Key> keys = new Queue<Key>();
midSearch(root, keys);
return keys;
}
public void midSearch(Node node, Queue<Key> keys) {
if (node == null) {
return;
}
// 遍历左子树，不为空时递归遍历
if (node.left != null) {
midSearch(node.left, keys);
}
// 将当前结点放入队列中
keys.enqueue((Key) node.key);
// 遍历右子树，不为空时递归遍历
if (node.right != null) {
midSearch(node.right, keys);
}
}
|
十三、 二叉树的遍历-层序遍历
层序遍历的实现思路
- 创建队列A，存储当前结点
- 循环队列A，首先弹出队列中的结点key，并存储到队列B中，如果当前结点的左子树不为空，则将左节点存储到队列A中，如果当前结点的右子树不为空，则将右结点存储到队列A中
/**
* 层序遍历实现
*/
public Queue<Key> layerSearch() {
Queue<Node> A = new Queue<Node>();
Queue<Key> B = new Queue<Key>();
A.enqueue(root);
while (!A.isEmpty()) {
Node n = A.dequeue();
B.enqueue((Key) n.key);
if (n.left != null) {
A.enqueue(n.left);
}
if (n.right != null) {
A.enqueue(n.right);
}
}
return B;
}
|
