树具有以下特点:
-
每个结点有 零个或多个 子结点
-
没有父结点的结点为 根结点
-
每一个非根结点 只有一个 父结点
-
每个结点及其后代结点整体上可以看做是一棵树,称为当前结点的父结点的一个 子树
- 结点的度
一个结点含有的子树的个数称为该结点的度
- 叶结点
度为0的结点称为叶结点,也可以叫做终端结点
- 分支结点
度不为0的结点称为分支结点,也可以叫做非终端结点
- 结点的层次
从根结点开始,根结点的层次为1,根的直接后继层次为2,以此类推
- 结点的层序编号
将树中的结点,按照从上层到下层,同层从左到右的次序排成一个线性序列,把他们编成连续的自然数
- 树的度
树中所有结点的度的最大值
- 树的高度(深度)
树中结点的最大层次
- 森林
m(m>=0)个互不相交的树的集合,将一颗非空树的根结点删去,树就变成一个森林;给森林增加一个统一的根结点,森林就变成一棵树
- 孩子结点
一个结点的直接后继结点称为该结点的孩子结点
- 双亲结点(父结点)
一个结点的直接前驱称为该结点的双亲结点
- 兄弟结点
同一双亲结点的孩子结点间互称兄弟结点
- 二叉树
就是度不超过2的树(每个结点最多有两个子结点)
- 满二叉树
一个二叉树,如果每一个层的结点树都达到最大值,则这个二叉树就是满二叉树
- 完全二叉树
叶节点只能出现在 最下层和次下层,并且最下面一层的结点都集中在该层 最左边 的若干位置的二叉树
除最下层外,其余层都是满的
1)二叉树的结点类
-
根据对图的观察,我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的,按照面向对象的思想,我们设计一个结点类来描述结点这个事物
-
结点API
public class Node<K,V> {
/**
- 键 key
*/
private K key;
/**
- 值 value
*/
private V value;
/**
- 左子结点
*/
private Node left;
/**
- 右子结点
*/
private Node right;
/**
-
构造器
-
@param key
-
@param value
-
@param left
-
@param right
*/
public Node(K key, V value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
2)二叉查找树API设计
3)二叉查找树实现
- 插入方法put实现思路
-
如果当前树中没有任何一个结点,则直接把新结点当做根结点使用
-
如果当前树不为空,则从根结点开始:
1) 如果新结点的key 小于 当前结点的key,则继续找当前结点的 左子结点
2) 如果新结点的key 大于 当前结点的key,则继续找当前结点的 右子结点
3)如果新结点的key 等于 当前结点的key,则树中已经存在这样的结点,替换 该结点的value值即可
- 查询方法get实现思路
从根节点开始:
-
如果要查询的key 小于 当前结点的key,则继续找当前结点的 左子结点
-
如果要查询的key 大于 当前结点的key,则继续找当前结点的 右子结点
-
如果要查询的key 等于 当前结点的key,则树中 返回 当前结点的value
- 删除方法delete实现思路
过河拆桥,再建新桥
-
找到被删除结点
-
找到被删除结点 右子树中的最小结点 minNode
-
删除右子树中的最小结点
-
让被删除结点的左子树成为最小结点minNode的左子树,让被删除结点的右子树称为最小结点minNode的右子树
-
让被删除结点的父节点指向最小结点minNode
- 代码实现
package chapter05;
/**
-
@author 土味儿
-
Date 2021/9/7
-
@version 1.0
-
二叉树
*/
public class BinaryTree<K extends Comparable, V> {
/**
- 根结点
*/
private Node root;
/**
- 树中元素个数
*/
private int n;
/**
- 构造器
*/
public BinaryTree() {
}
/**
-
向树中插入一个新结点(键值对)
-
@param key
-
@param value
*/
public void put(K key, V value) {
root = put(root, key, value);
}
/**
-
向树x中插入新结点,并返回新树
-
@param x
-
@param key
-
@param value
-
@return
*/
private Node put(Node x, K key, V value) {
// 如果树x为空,创建新结点,让新结点成为x,元素数量加1,并返回x
if (x == null) {
n++;
return new Node(key, value, null, null);
}
// 如果树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
x.right = put(x.right, key, value);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
x.left = put(x.left, key, value);
} else {
// 如果相等,value 替换 x的值
x.value = value;
}
return x;
}
/**
-
找出结点key的值
-
@param key
-
@return
*/
public V get(K key) {
return get(root, key);
}
/**
-
找出树x中结点key的值
-
@param x
-
@param key
-
@return
*/
private V get(Node x, K key) {
// 树x为空
if (x == null) {
return null;
}
// 树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
return get(x.right, key);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
return get(x.left, key);
} else {
// 如果相等,就找到了,返回x的value
return x.value;
}
}
/**
-
删除结点key
-
@param key
*/
public void delete(K key) {
delete(root, key);
}
/**
-
删除树x中的结点key,并返回新树
-
@param x
-
@param key
-
@return
*/
private Node delete(Node x, K key) {
// 树x为空
if (x == null) {
return null;
}
// 树x不为空,比较key与x键的大小
int cpt = x.key.compareTo(key);
if (cpt < 0) {
// 如果key 大于 x的键,比较右子树 (递归)
x.right = delete(x.right, key);
} else if (cpt > 0) {
// 如果key 小于 x的键,比较左子树 (递归)
x.left = delete(x.left, key);
} else {
// 如果相等,就找到了
// 元素数量减1
n–;
// 特殊情况:当前树x只有一个分叉,左或右
if (x.left == null) {
// 没有左子树,直接返回右子树即可
return x.right;
}
if (x.right == null) {
// 没有右子树,直接返回左子树即可
return x.left;
}
// 左右子树都存在
// 找出右子树中的最小结点minNode,并在右子树中删除minNode
Node minNode;
Node node = x.right;
while (node.left != null) {
// 移动minNode指针
minNode = node.left;
if (node.left.left == null) {
// 如果node.left没有下级结点,即为最小结点,设为null值,即为删除
node.left = null;
} else {
// 如果node.left有下级结点,移动node指针
node = node.left;
}
}
// 让被删除结点x的左子树成为minNode的左子树
minNode.left = x.left;
// 让被删除结点x的右子树(已删除minNode)成为minNode的右子树
minNode.right = x.right;
// 用minNode替换被删除结点x(被删除结点的父节点指向最小结点minNode)
x = minNode;
}
return x;
}
/**
-
获取树中元素个数
-
@return
*/
public int size() {
return n;
}
/**
- 内部结点类
*/
private class Node {
/**
- 键 key
*/
private K key;
/**
- 值 value
*/
private V value;
/**
- 左子结点
*/
private Node left;
/**
- 右子结点
*/
private Node right;
/**
-
构造器
-
@param key
-
@param value
-
@param left
-
@param right
*/
public Node(K key, V value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
}
package chapter05;
import org.junit.Test;
/**
-
@author 土味儿
-
Date 2021/9/7
-
@version 1.0
-
测试二叉树
*/
public class BinaryTreeTest {
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,“张三”);
bt.put(2,“李四”);
bt.put(8,“王五”);
bt.put(6,“赵六”);
bt.put(3,“四七”);
System.out.println(“元素个数:”+bt.size());
bt.put(6,“秦八”);
System.out.println(“元素个数:”+bt.size());
bt.delete(8);
System.out.println(“删除后元素个数:”+bt.size());
System.out.println(bt.get(8));
}
}
元素个数:5
元素个数:5
删除后元素个数:4
null
4)二叉查找树其他便捷方法
1、查找二叉树中最小的键
-
API设计
-
递归方式
-
while循环方式
-
代码实现
/**
-
方法一:找出树中最小的键
-
while循环方式
-
@return
*/
public K min1() {
Node x = root;
if (x == null) {
return null;
}
while (x.left != null) {
x = x.left;
}
return x.key;
}
/**
-
方法二:找出树中最小的键
-
递归方式
-
@return
*/
public K min2() {
Node min = min(root);
if (min != null) {
return min.key;
}
return null;
//return min(root).key;
}
/**
-
找出树x中的最小键的结点
-
@param x
-
@return
*/
private Node min(Node x) {
if (x != null && x.left != null) {
//if (x.left != null) {
return min(x.left);
}
return x;
}
public class BinaryTreeTest {
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,“张三”);
bt.put(2,“李四”);
bt.put(8,“王五”);
bt.put(6,“赵六”);
bt.put(3,“四七”);
System.out.println(“方法1最小键:”+bt.min1());
System.out.println(“方法2最小键:”+bt.min2());
}
}
方法1最小键:2
方法2最小键:2
2、查找二叉树中最大的键
-
API设计
-
递归方式
-
while循环方式
-
代码实现
/**
-
方法一:找出树中最大的键
-
while循环方式
-
@return
*/
public K max1(){
Node x = root;
if (x == null) {
return null;
}
while (x.right != null) {
x = x.right;
}
return x.key;
}
/**
-
方法二:找出树中最大的键
-
递归方式
-
@return
*/
public K max2(){
Node max = max(root);
if (max != null) {
return max.key;
}
return null;
}
/**
-
找出树x中的最大键的结点
-
@param x
-
@return
*/
private Node max(Node x) {
if (x != null && x.right != null) {
return max(x.right);
}
return x;
}
@Test
public void test(){
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(5,“张三”);
bt.put(2,“李四”);
bt.put(8,“王五”);
bt.put(6,“赵六”);
bt.put(3,“四七”);
System.out.println(“方法1最大键:”+bt.max1());
System.out.println(“方法2最大键:”+bt.max2());
}
方法1最大键:8
方法2最大键:8
深度优先
很多情况下,可能需要像遍历数组一样遍历树, 从而拿出树中存储的每一个元素,由于树状结构和线性结构不一样,没有办法从头依次向后遍历,所以存在如何遍历,也就是按照什么样的搜索路径进行遍历的问题
把树简单的画作上图中的样子,由一个根节点、一个左子树、一个右子树组成,那么按照 根节点 什么时候被访问,可以把二叉树的遍历分为以下三种方式:
- 前序遍历:根左右
先访问根结点,然后再访问左子树,最后访问右子树
- 中序遍历:左根右
先访问左子树,中间访问根节点,最后访问右子树
- 后序遍历:左右根
先访问左子树,再访问右子树,最后访问根节点
如果分别对下面的树使用三种遍历方式进行遍历,得到的结果如下:
1)前序遍历
- 在上图树上,添加前序遍历的API:
public Queue preErgodic() // 使用前序遍历,获取整个树中的所有键
private void preErgodic(Node x,Queue keys) //使用前序遍历,把指定树x中的所有键放入到keys队列中;实现过程中,通过前序遍历,把每个结点的键取出,放入到队列中返回即可
- 实现步骤
-
把当前结点的key放入到队列中
-
找到当前结点的左子树,如果不为空,递归遍历左子树
-
找到当前结点的右子树,如果不为空,递归遍历右子树
- 代码实现
/**
-
前序遍历二叉树,返回key的队列
-
@return
*/
public Queue preErdogic() {
Queue keys = new Queue<>();
preErdogic(root,keys);
return keys;
}
/**
-
前序遍历树x,把key放入keys中
-
@param x
-
@param keys
*/
private void preErdogic(Node x, Queue keys) {
// x为空
if (x == null) {
return;
}
// x不为空
// 把x(即根)的key放入keys
keys.enQueue(x.key);
// 如果x的左子树不为空,递归调用
if (x.left != null) {
preErdogic(x.left, keys);
}
// 如果x的右子树不为空,递归调用
if (x.right != null) {
preErdogic(x.right, keys);
}
}
@Test
public void testPreErdogic() {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put(“E”, “5”);
bt.put(“B”, “2”);
bt.put(“G”, “7”);
bt.put(“A”, “1”);
bt.put(“D”, “4”);
bt.put(“F”, “6”);
bt.put(“H”, “8”);
bt.put(“C”, “3”);
Queue keys = bt.preErdogic();
for (String k : keys) {
System.out.println(k + " – " + bt.get(k));
}
}
E – 5
B – 2
A – 1
D – 4
C – 3
G – 7
F – 6
H – 8
2)中序遍历
中序遍历结果是有序的
- 在上图的树上,添加中序遍历的API:
public Queue midErgodic() // 使用中序遍历,获取整个树中的所有键
private void midErgodic(Node x,Queue keys) // 使用中序遍历,把指定树x中的所有键放入到keys队列中
- 实现步骤
-
找到当前结点的左子树,如果不为空,递归遍历左子树
-
把当前结点的key放入到队列中
-
找到当前结点的右子树,如果不为空,递归遍历右子树
- 代码实现
/**
-
中序遍历二叉树,返回key的队列
-
@return
*/
public Queue midErdogic() {
Queue keys = new Queue<>();
midErdogic(root,keys);
return keys;
}
/**
-
中序遍历树x,把key放入keys中
-
@param x
-
@param keys
*/
private void midErdogic(Node x, Queue keys) {
// x为空
if (x == null) {
return;
}
// x不为空
// 如果x的左子树不为空,递归调用
if (x.left != null) {
midErdogic(x.left, keys);
}
// 把x(即根)的key放入keys
keys.enQueue(x.key);
// 如果x的右子树不为空,递归调用
if (x.right != null) {
midErdogic(x.right, keys);
}
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/96c3aef91471ca1db9028ecd60d9be3c.jpeg)
最后
既已说到spring cloud alibaba,那对于整个微服务架构,如果想要进一步地向上提升自己,到底应该掌握哪些核心技能呢?
就个人而言,对于整个微服务架构,像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识,架构师必经之路!下图,是自绘的微服务架构路线体系大纲,如果有还不知道自己该掌握些啥技术的朋友,可根据小编手绘的大纲进行一个参考。
如果觉得图片不够清晰,也可来找小编分享原件的xmind文档!
且除此份微服务体系大纲外,我也有整理与其每个专题核心知识点对应的最强学习笔记:
-
出神入化——SpringCloudAlibaba.pdf
-
SpringCloud微服务架构笔记(一).pdf
-
SpringCloud微服务架构笔记(二).pdf
-
SpringCloud微服务架构笔记(三).pdf
-
SpringCloud微服务架构笔记(四).pdf
-
Dubbo框架RPC实现原理.pdf
-
Dubbo最新全面深度解读.pdf
-
Spring Boot学习教程.pdf
-
SpringBoo核心宝典.pdf
-
第一本Docker书-完整版.pdf
-
使用SpringCloud和Docker实战微服务.pdf
-
K8S(kubernetes)学习指南.pdf
另外,如果不知道从何下手开始学习呢,小编这边也有对每个微服务的核心知识点手绘了其对应的知识架构体系大纲,不过全是导出的xmind文件,全部的源文件也都在此!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
OPPO等大厂,18年进入阿里一直到现在。**
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。[外链图片转存中…(img-LaYi12Ym-1713549783609)]
[外链图片转存中…(img-VTq266qj-1713549783612)]
[外链图片转存中…(img-ho0p1PhR-1713549783613)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/96c3aef91471ca1db9028ecd60d9be3c.jpeg)
最后
既已说到spring cloud alibaba,那对于整个微服务架构,如果想要进一步地向上提升自己,到底应该掌握哪些核心技能呢?
就个人而言,对于整个微服务架构,像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识,架构师必经之路!下图,是自绘的微服务架构路线体系大纲,如果有还不知道自己该掌握些啥技术的朋友,可根据小编手绘的大纲进行一个参考。
[外链图片转存中…(img-hGplVl8D-1713549783614)]
如果觉得图片不够清晰,也可来找小编分享原件的xmind文档!
且除此份微服务体系大纲外,我也有整理与其每个专题核心知识点对应的最强学习笔记:
-
出神入化——SpringCloudAlibaba.pdf
-
SpringCloud微服务架构笔记(一).pdf
-
SpringCloud微服务架构笔记(二).pdf
-
SpringCloud微服务架构笔记(三).pdf
-
SpringCloud微服务架构笔记(四).pdf
-
Dubbo框架RPC实现原理.pdf
-
Dubbo最新全面深度解读.pdf
-
Spring Boot学习教程.pdf
-
SpringBoo核心宝典.pdf
-
第一本Docker书-完整版.pdf
-
使用SpringCloud和Docker实战微服务.pdf
-
K8S(kubernetes)学习指南.pdf
[外链图片转存中…(img-BXbotHBu-1713549783615)]
另外,如果不知道从何下手开始学习呢,小编这边也有对每个微服务的核心知识点手绘了其对应的知识架构体系大纲,不过全是导出的xmind文件,全部的源文件也都在此!
[外链图片转存中…(img-iWfoMGRU-1713549783617)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!