树具有以下特点：
-
每个结点有 零个或多个 子结点
-
没有父结点的结点为 根结点
-
每一个非根结点 只有一个 父结点
-
每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个 子树
- 结点的度
一个结点含有的子树的个数称为该结点的度
- 叶结点
度为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获取）
最后的内容
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）
如何准备面试？
1、前期铺垫（技术沉积）
程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。
下面是我会看的一些资料笔记，希望能帮助大家由浅入深，由点到面的学习Java，应对大厂面试官的灵魂追问
这部分内容过多，小编只贴出部分内容展示给大家了，见谅见谅！
- Java程序员必看《Java开发核心笔记（华山版）》
- Redis学习笔记
- Java并发编程学习笔记
四部分，详细拆分并发编程——并发编程+模式篇+应用篇+原理篇
- Java程序员必看书籍《深入理解 ava虚拟机第3版》（pdf版）
- 大厂面试必问——数据结构与算法汇集笔记
其他像Spring，SpringBoot，SpringCloud，SpringCloudAlibaba，Dubbo，Zookeeper，Kafka，RocketMQ，RabbitMQ，Netty，MySQL，Docker，K8s等等我都整理好，这里就不一一展示了。
2、狂刷面试题
技术主要是体现在平时的积累实用，面试前准备两个月的时间再好好复习一遍，紧接着就可以刷面试题了，下面这些面试题都是小编精心整理的，贴给大家看看。
①大厂高频45道笔试题（智商题）
②BAT大厂面试总结（部分内容截图）
③面试总结
3、结合实际，修改简历
程序员的简历一定要多下一些功夫，尤其是对一些字眼要再三斟酌，如“精通、熟悉、了解”这三者的区别一定要区分清楚，否则就是在给自己挖坑了。当然不会包装，我可以将我的简历给你参考参考，如果还不够，那下面这些简历模板任你挑选：
以上分享，希望大家可以在金三银四跳槽季找到一份好工作，但千万也记住，技术一定是平时工作种累计或者自学（或报班跟着老师学）通过实战累计的，千万不要临时抱佛脚。
另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）
如何准备面试？
1、前期铺垫（技术沉积）
程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。
下面是我会看的一些资料笔记，希望能帮助大家由浅入深，由点到面的学习Java，应对大厂面试官的灵魂追问
这部分内容过多，小编只贴出部分内容展示给大家了，见谅见谅！
- Java程序员必看《Java开发核心笔记（华山版）》
[外链图片转存中…(img-iRd0WfAZ-1713421248813)]
- Redis学习笔记
[外链图片转存中…(img-08TzvZOb-1713421248813)]
- Java并发编程学习笔记
四部分，详细拆分并发编程——并发编程+模式篇+应用篇+原理篇
[外链图片转存中…(img-vfD4R9RQ-1713421248813)]
- Java程序员必看书籍《深入理解 ava虚拟机第3版》（pdf版）
[外链图片转存中…(img-eCHJyiNi-1713421248813)]
- 大厂面试必问——数据结构与算法汇集笔记
[外链图片转存中…(img-xhKmkYYt-1713421248813)]
其他像Spring，SpringBoot，SpringCloud，SpringCloudAlibaba，Dubbo，Zookeeper，Kafka，RocketMQ，RabbitMQ，Netty，MySQL，Docker，K8s等等我都整理好，这里就不一一展示了。
[外链图片转存中…(img-CSm8t5QX-1713421248814)]
2、狂刷面试题
技术主要是体现在平时的积累实用，面试前准备两个月的时间再好好复习一遍，紧接着就可以刷面试题了，下面这些面试题都是小编精心整理的，贴给大家看看。
①大厂高频45道笔试题（智商题）
[外链图片转存中…(img-j31tv6PV-1713421248814)]
②BAT大厂面试总结（部分内容截图）
[外链图片转存中…(img-VYx0l53X-1713421248814)]
[外链图片转存中…(img-T6RoxHOa-1713421248814)]
③面试总结
[外链图片转存中…(img-hF62Fck8-1713421248814)]
[外链图片转存中…(img-L2x92IwA-1713421248814)]
3、结合实际，修改简历
程序员的简历一定要多下一些功夫，尤其是对一些字眼要再三斟酌，如“精通、熟悉、了解”这三者的区别一定要区分清楚，否则就是在给自己挖坑了。当然不会包装，我可以将我的简历给你参考参考，如果还不够，那下面这些简历模板任你挑选：
[外链图片转存中…(img-tWW3BKb3-1713421248815)]
以上分享，希望大家可以在金三银四跳槽季找到一份好工作，但千万也记住，技术一定是平时工作种累计或者自学（或报班跟着老师学）通过实战累计的，千万不要临时抱佛脚。
另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
2521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
