树
我们常用数组、链表存储数据，但这两者都各有优缺点：
- 数组：访问速度快，增加、删除速度慢，需要创建新数组
- 链表：增加、删除快，访问慢，访问时需要从头开始遍历
有什么能综合两个优点，提高存取、访问效率的数据结构？
提出了树的数据结构：
- 树是一种数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
- 它具有以下的特点：
每个结点有零个或多个子结点；
没有父结点的结点称为根结点；
每一个非根结点有且只有一个父结点；
除了根结点外，每个子结点可以分为多个不相交的子树
为什么树能提升存取、访问效率？
树类似与链表，有指向子结点的指针，即保留了链表的增删效率，设置层次，增加了访问效率
需要了解树的基本术语：
- 结/节点：存放的一个数据项
- 根结点：没有父结点的结点，也就是最上级的结点
- 父结点、子结点
- 叶子结点：没有子结点的结点
- 权：结点的值
- 路径：从根结点到该结点的路线
- 层：上图有3个层，根结点为第一层
- 度：结点x的子结点数称为x的度，如上图根节点度为3
- 子树：树的其中一个结点以及其下面的所有的结点所构成的树
- 高/深度：高度是从结点x向下到某个叶结点最长简单路径中边的条数；深度定义是从上往下的，高度定义是从下往上的；但都是一样的
- 树的高/深度：该树的最大层数
- 森林：多棵树构成森林（森林中的树不相连，上面的树去掉根结点就是包含3棵树的森林）
关于上面的度、深度、高度计算一般是从1开始，但是也有从0开始的
二叉树
树结构一个结点可以有多个子结点，而二叉树是每个节点最多含有两个子树的树
我们把二叉树的子结点分为左结点、右结点
二叉树有很多种类：
- 从结构角度有完全二叉树、满二叉树
- 从属性角度有二叉查找树、平衡二叉树、AVL树、红黑树等等
这里仅解析、实现普通的二叉树，其他的复杂的树后续完成
完全二叉树
如果二叉树除了最后一层其他层全部填满，且最后一层左边连续，称该二叉树为完全二叉树
满二叉树
如果二叉树所有层全部被填满，称为满二叉树
很明显，满二叉树是特殊的完全二叉树
满二叉树具有以下性质：
1、一个层数为k 的满二叉树总结点数为：2K-1，因此满二叉树的结点数一定是奇数个
2、第i层上的结点数为：2i-1个
二叉查找树
二叉查找树是从树的节点属性角度判断，与树的结构无关
如果每棵树的根节点的值都比左子树上所有节点值要大，也都比右子树上所有节点值要小，称为二叉查找树
二叉树的遍历方式
二叉树的遍历方式有4种：
- 层次遍历：从根结点开始从上往下遍历，同一层从左往右遍历，上面的二叉查找树的层次遍历为
40,11,66,7,18,50,100,2,8 - 先/前序遍历：先输出父节点，再遍历左子树，再遍历右子树，上面的二叉查找树的先序遍历为
40,11,7,2,8,18,66,50,100 - 中序遍历：先遍历左子树，再输出父节点，再遍历右子树，上面的二叉树的中序遍历为
2,7,8,11,18,40,50,66,100，很明显，中序遍历输出的是有序结果 - 后序遍历：先遍历左子树，再遍历右子树，再输出父节点，上面的二叉树的后序遍历为
2,8,7,18,11,50,100,66,40
其中，前序、中序、后序遍历通过递归即可实现，只需调整
- 输出父结点
- 遍历左子树
- 遍历右子树
3个步骤的顺序
层次遍历可以通过队列实现：
- 当前二叉树，创建一个队列，依靠先进先出的特性层次遍历
-
先遍历第一次，也就是根结点，放入队列
-
打印根节点后，取出根结点，判断是否存在左、右结点，存在就按左、右顺序放入
- 继续取出结点2，判断是否存在左右结点，2不存在左右结点
-
取出结点3，判断左右结点，按顺序放入
-
继续取出队列内的结点，判断左右结点，直到队列为空
-
层次遍历的结果为
1,2,3,5,4
Java实现二叉树及四种遍历
二叉树结点和链表的结点类似
创建结点对象HeroNode
- 有四个属性，left、right指向左右结点
- 递归实现先序遍历、中序遍历、后序遍历，只需调整：输出父结点、遍历左子树、遍历右子树的顺序
- 层次遍历：按照上面的步骤，借助Java的集合对象LinkedList实现
//创建HeroNode结点
class HeroNode{
private int no;
private String name;
//左右结点，默认为null
private HeroNode left;
private HeroNode right;
public HeroNode(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public HeroNode setNo(int no) {
this.no = no;
return this;
}
public String getName() {
return name;
}
public HeroNode setName(String name) {
this.name = name;
return this;
}
public HeroNode getLeft() {
return left;
}
public HeroNode setLeft(HeroNode left) {
this.left = left;
return this;
}
public HeroNode getRight() {
return right;
}
public HeroNode setRight(HeroNode right) {
this.right = right;
return this;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
//层次遍历
public void levelOrder(){
//使用队列保存结点
LinkedList<HeroNode> heroNodes = new LinkedList<>();
//将根节点加入队列
heroNodes.add(this);
while ( !heroNodes.isEmpty() ){
//轮询队列中的结点
HeroNode father = heroNodes.poll();
System.out.println(father);
//查看该结点是否存在左、右结点
if (father.left != null){
//存在左结点，加入队列
heroNodes.add(father.left);
}
if (father.right != null){
//存在右结点，加入队列
heroNodes.add(father.right);
}
}
}
//前序遍历方法
public void preOrder(){
//1.先输出父结点
System.out.println(this);
//2.递归向左子树前序遍历
if (this.left != null){
this.left.preOrder();
}
//3.递归向右子树前序遍历
if (this.right != null){
this.right.preOrder();
}
}
//中序遍历
public void infixOrder(){
//1.先递归向左子树中序遍历
if (this.left != null){
this.left.infixOrder();
}
//2.输出父结点
System.out.println(this);
//3.递归右子树中序遍历
if (this.right != null){
this.right.infixOrder();
}
}
//后序遍历
public void postOrder(){
//1.先递归左子树后序遍历
if (this.left != null){
this.left.postOrder();
}
//2.递归右子树后序遍历
if (this.right != null){
this.right.postOrder();
}
//3.输出父结点
System.out.println(this);
}
}
定义二叉树，只需要设置根结点以及调用结点的方法
//定义BinaryTree,二叉树
class BinaryTree{
//根结点
private HeroNode root;
public BinaryTree() {
}
public void setRoot(HeroNode root) {
this.root = root;
}
//前序遍历
public void preOrder(){
if (this.root != null){
System.out.println("=== 前序遍历 ===");
this.root.preOrder();
}
else {
System.out.println("=== 当前二叉树为空 ===");
}
}
//中序遍历
public void infixOrder(){
if (this.root != null){
System.out.println("=== 中序遍历 ===");
this.root.infixOrder();
}
else {
System.out.println("=== 当前二叉树为空 ===");
}
}
//后序遍历
public void postOrder(){
if (this.root != null){
System.out.println("=== 后序遍历 ===");
this.root.postOrder();
}
else {
System.out.println("=== 当前二叉树为空 ===");
}
}
//层次遍历
public void levelOrder(){
if (this.root != null){
System.out.println("=== 层次遍历 ===");
this.root.levelOrder();
}
else {
System.out.println("=== 当前二叉树为空 ===");
}
}
}
测试类：
package com.company.tree;
import java.util.LinkedList;
/**
* @author zfk
*
* 二叉树
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//创建二叉树
BinaryTree binaryTree = new BinaryTree();
//创建结点
HeroNode root = new HeroNode(1,"宋江");
HeroNode heroNode2 = new HeroNode(2,"吴用");
HeroNode heroNode3 = new HeroNode(3,"卢俊义");
HeroNode heroNode4 = new HeroNode(4,"林冲");
HeroNode heroNode5 = new HeroNode(5,"鲁智深");
//手动创建二叉树
// 1
// 2 3
// 5 4
root.setLeft(heroNode2);
root.setRight(heroNode3);
heroNode3.setRight(heroNode4);
heroNode3.setLeft(heroNode5);
binaryTree.setRoot(root);
//前序遍历 1,2,3,5,4
binaryTree.preOrder();
//中序遍历 2,1,5,3,4
binaryTree.infixOrder();
//后序遍历 2,5,4,3,1
binaryTree.postOrder();
//层次遍历 1,2,3,5,4
binaryTree.levelOrder();
}
}
对于输入的1,2,3,4,5的数据，4种遍历结果为：
关于遍历查找
前面的4种遍历方式，可以用来查找指定的结点，方法就是在遍历的过程中比较no
通过Java实现遍历查找：在上面的3个类的基础上添加了方法
HeroNode类中添加4种遍历查找的实现：
- 层次、前序、中序、后序查找基本与遍历方法类型，只是多了个比较
- 设置一个输出语句在比较方法上，输出次数即为查找次数
/**
* @param no 要查找的结点no
* @return 找到就返回该结点，没有就返回null
* 层次遍历查找
*/
public HeroNode levelOrderSearch(int no){
//新建队列，存放树的结点
LinkedList<HeroNode> list = new LinkedList<>();
list.add(this);
HeroNode resNode = null;
//遍历队列
while (!list.isEmpty()){
//取出队列的第一个结点
HeroNode father = list.poll();
//比较该结点
System.out.println("=== 进入层次遍历查找 ===");
if (father.no == no){
//找到了就直接退出循环
resNode = father;
break;
}
//如果左右结点不为null，加入队列
if (father.left != null){
list.add(father.left);
}
if (father.right != null){
list.add(father.right);
}
}
return resNode;
}
/**
* @param no 要查找no
* @return 找到就返回该结点，没有就返回null
* 前序遍历查找
*/
public HeroNode preOrderSearch(int no){
System.out.println("=== 进入前序遍历查找 ===");
//比较当前结点是否为要查找的结点
if (this.no == no){
return this;
}
//判断当前结点的左结点是否为空，不是则左递归前序查找
HeroNode resNode = null;
if (this.left != null){
resNode = this.left.preOrderSearch(no);
}
if (resNode != null){
//说明左子树找到了,直接返回
return resNode;
}
//判断当前结点的右结点是否为空，不是则右递归
if (this.right != null){
resNode = this.right.preOrderSearch(no);
}
//右递归后返回结果
return resNode;
}
/**
* @param no 要查找的结点
* @return 找到就返回该结点，没有就返回null
* 中序遍历查找
*/
public HeroNode infixOrderSearch(int no){
//判断当前结点的左结点是否为空，不是则左递归前序查找
HeroNode resNode = null;
if (this.left != null){
resNode = this.left.infixOrderSearch(no);
}
if (resNode != null){
//说明左子树找到了,直接返回
return resNode;
}
System.out.println("=== 进入中序遍历查找 ===");
//比较当前结点是否为要查找的结点
if (this.no == no){
return this;
}
//判断当前结点的右结点是否为空，不是则右递归
if (this.right != null){
resNode = this.right.infixOrderSearch(no);
}
//右递归后返回结果
return resNode;
}
/**
* @param no 要查找的结点
* @return 找到就返回该结点，没有就返回null
* 后序遍历查找
*/
public HeroNode postOrderSearch(int no){
//判断当前结点的左结点是否为空，不是则左递归前序查找
HeroNode resNode = null;
if (this.left != null){
resNode = this.left.postOrderSearch(no);
}
if (resNode != null){
//说明左子树找到了,直接返回
return resNode;
}
//判断当前结点的右结点是否为空，不是则右递归
if (this.right != null){
resNode = this.right.postOrderSearch(no);
}
if (resNode != null){
//说明右子树找到了，直接返回
return resNode;
}
System.out.println("=== 进入后序遍历查找 ===");
//左右子树都没找到，比较当前结点是否为要查找的结点
if (this.no == no){
return this;
}
return resNode;
}
BinaryTree类：增加对应的遍历查找的调用
//层次遍历查找
public HeroNode levelOrderSearch(int no){
if (root != null){
return root.levelOrderSearch(no);
}
else {
return null;
}
}
//前序遍历查找
public HeroNode preOrderSearch(int no){
if (root != null){
//根结点不为空，直接调用前序遍历方法
return root.preOrderSearch(no);
}
else {
return null;
}
}
//中序遍历查找
public HeroNode infixOrderSearch(int no){
if (root != null){
//根结点不为空，直接调用中序遍历方法
return root.infixOrderSearch(no);
}
else {
return null;
}
}
//后序遍历查找
public HeroNode postOrderSearch(int no){
if (root != null){
//根结点不为空，直接调用后序遍历方法
return root.postOrderSearch(no);
}
else {
return null;
}
}
测试方法：
public class BinaryTreeDemo {
public static void main(String[] args) {
//创建二叉树
BinaryTree binaryTree = new BinaryTree();
//创建结点
HeroNode root = new HeroNode(1,"宋江");
HeroNode heroNode2 = new HeroNode(2,"吴用");
HeroNode heroNode3 = new HeroNode(3,"卢俊义");
HeroNode heroNode4 = new HeroNode(4,"林冲");
HeroNode heroNode5 = new HeroNode(5,"鲁智深");
//手动创建二叉树
// 1
// 2 3
// 5 4
root.setLeft(heroNode2);
root.setRight(heroNode3);
heroNode3.setRight(heroNode4);
heroNode3.setLeft(heroNode5);
binaryTree.setRoot(root);
//前序查找
HeroNode resNode = binaryTree.preOrderSearch(5);
//HeroNode resNode = binaryTree.infixOrderSearch(5);
//HeroNode resNode = binaryTree.postOrderSearch(5);
//HeroNode resNode = binaryTree.levelOrderSearch(5);
if (resNode != null){
System.out.println("已找到："+resNode);
}
else {
System.out.println("没有找到英雄");
}
}
}
前序遍历查找：根据遍历的过程可以知道需要四次：1,2,3,5
相应的中序遍历查找需要3次：2,1,5
后序遍历查找需要2次：2,5
层次遍历查找需要4次：1,2,3,5
总结
树是一个很重要的数据结构，本篇文章了解到：
- 树：有限结点组成的一个有层次关系的集合
- 二叉树：每个结点最多含义两个子树的树
- 二叉树有很多种类：完全二叉树、满二叉树、二叉查找树等
- 二叉树有4种遍历方式：层次遍历、先序遍历、中序遍历、后序遍历，这4种遍历方式又可以延伸出4种遍历查找
这里仅解析实现了二叉树和四种遍历，后续完成二叉查找树及其他的复杂的二叉树
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
