Java数据结构与算法高级篇之树、图
数据是基础，算法是灵魂
本文出自门心叼龙的博客，属于原创类容，转载请注明出处。https://blog.csdn.net/geduo_83/article/details/86557628
源码下载地址：https://download.csdn.net/download/geduo_83/10913510
初级篇：Java数据结构与算法初级篇之数组、集合和散列表
中级篇：Java数据结构与算法中级篇之栈、队列、链表
高级篇：Java数据结构与算法高级篇之树、图
理论篇：Java数组、集合、散列表常见算法浅析
理论篇：Java栈、队列、链表常见算法浅析
理论篇：Java树、图常见算法浅析
1.前言
2.树
2.1 树的概念
2.2 满二叉树
2.3 完全二叉树
2.4 红黑树
2.5 相关算法
3.图
3.1 概念
3.2 存储结构
3.3 图的实现
4.小结
1.前言
2010年的一部电影创造了奇迹，它是全球第一部票房到达27亿美元，总票房及时排名第一的影片，那就是詹姆斯.卡梅隆执导的电影《阿凡达》。
电影里提到了一颗高大274米的参天大树，是那个潘多拉星球的纳威人的家园，让人印象非常深刻。可惜那只是导演的梦想，地球上不存在这样的物种。
无论多高大的树，那也是从小到大、由根到叶、一点点成长起来的。俗话说十年树木、百年树人，一棵大树又何止是十年这样的容易。而今天我们讲另外一种新的数据结构--树。
2.树
2.1 树的概念
有N个节点组成，具有一定层次关系的集合。
2.2 满二叉树
note = 2^k - 1
2.3 完全二叉树
2.3.1 特点
- 叶子节点都在k或者k-1层
- k层可以是不满的，但是k层的所有节点都
- 必须集中在最左边
2.3.2 堆
- 大顶堆：父节点都大于子节点
- 小顶堆：附近点都小于子节点
2.4 红黑树
- 根节点都是黑色的
- 红色节点的子节点都必须是黑色的
- 叶子结点都必须是null
- 任意节点到其所有路径所包含的黑色节点的个数是相同的
2.5 相关算法
- 求二叉树的高节点数中序遍历
package F树.A001求二叉树的高节点数中序遍历;
/**
* Description: <求二叉树的节点数高遍历>
* Author: 门心叼龙
* Date: 2018/11/21
* Version: V1.0.0
* Update:
*/
public class MainAlgorithm {
public static void main(String[] args) {
TreeNode treeNode = new TreeNode(0);
TreeNode treeNode1 = new TreeNode(1);
TreeNode treeNode2 = new TreeNode(2);
TreeNode treeNode3 = new TreeNode(3);
TreeNode treeNode4 = new TreeNode(4);
TreeNode treeNode5 = new TreeNode(5);
treeNode.setLeftNote(treeNode1);
treeNode.setRightNote(treeNode2);
treeNode1.setLeftNote(treeNode3);
treeNode1.setRightNote(treeNode4);
treeNode3.setLeftNote(treeNode5);
printTreeNote(treeNode);
}
// 求这个二叉树的高
public static int getTreeHeight(TreeNode treeNode) {
if (treeNode == null) {
return 0;
} else {
int leftHeight = 1 + getTreeHeight(treeNode.getLeftNote());
int rightHeight = 1 + getTreeHeight(treeNode.getRightNote());
if (leftHeight > rightHeight) {
return leftHeight;
} else {
return rightHeight;
}
}
}
// 遍历二叉树的所有节点
public static void printTreeNote(TreeNode treeNode) {
if (treeNode == null) {
return;
} else {
System.out.println(treeNode.getValue());
printTreeNote(treeNode.getLeftNote());
// System.out.println(treeNode.getValue());//中序遍历
printTreeNote(treeNode.getRightNote());
}
}
// 求二叉树节点的个数
public static int getTreeNodeCount(TreeNode treeNode) {
if (treeNode == null) {
return 0;
} else {
return 1 + getTreeNodeCount(treeNode.getLeftNote())
+ getTreeNodeCount(treeNode.getRightNote());
}
}
}- 判断两个二叉树是否完全相同：
package F树.A002判断两颗二叉树是否完全相同;
import F树.A001求二叉树的高节点数中序遍历.TreeNode;
/**
* Description: <判断两颗二叉树是否完全相同>
* Author: gxl
* Date: 2018/11/23
* Version: V1.0.0
* Update:
*/
public class MainAlgorithm {
public static void main(String[] args) {
TreeNode treeNode = new TreeNode(0);
TreeNode treeNode1 = new TreeNode(1);
TreeNode treeNode2 = new TreeNode(2);
TreeNode treeNode3 = new TreeNode(3);
TreeNode treeNode4 = new TreeNode(4);
TreeNode treeNode5 = new TreeNode(5);
treeNode.setLeftNote(treeNode1);
treeNode.setRightNote(treeNode2);
treeNode1.setLeftNote(treeNode3);
treeNode1.setRightNote(treeNode4);
treeNode3.setLeftNote(treeNode5);
// ===============================
TreeNode treeNode0 = new TreeNode(0);
TreeNode treeNode11 = new TreeNode(11);
TreeNode treeNode22 = new TreeNode(2);
TreeNode treeNode33 = new TreeNode(3);
TreeNode treeNode44 = new TreeNode(4);
TreeNode treeNode55 = new TreeNode(5);
treeNode0.setLeftNote(treeNode11);
treeNode0.setRightNote(treeNode22);
treeNode11.setLeftNote(treeNode33);
treeNode11.setRightNote(treeNode44);
treeNode33.setLeftNote(treeNode55);
boolean sameTree = isSameTree(treeNode, treeNode0);
System.out.println(sameTree);
}
//每个节点对应的值一样就可以
public static boolean isSameTree(TreeNode treeNode, TreeNode treeNode1) {
if (treeNode == null && treeNode1 == null) {
return true;
}
if (treeNode != null && treeNode1 == null) {
return false;
}
if (treeNode == null && treeNode1 != null) {
return false;
}
return (treeNode.getValue() == treeNode1.getValue())
&& isSameTree(treeNode.getLeftNote(), treeNode1.getLeftNote())
&& isSameTree(treeNode.getRightNote(), treeNode1.getRightNote());
}
}- 判断一个二叉树是否是对称二叉树
package F树.A003判断一个二叉树是否是对称二叉树;
import F树.A001求二叉树的高节点数中序遍历.TreeNode;
/**
* Description: <一个二叉树是否是对称二叉树>
* Author: gxl
* Date: 2018/11/23
* Version: V1.0.0
* Update:
*/
public class MainAlgorithm {
public static void main(String[] args) {
TreeNode treeNode = new TreeNode(0);
TreeNode treeNode1 = new TreeNode(10);
TreeNode treeNode2 = new TreeNode(10);
TreeNode treeNode3 = new TreeNode(20);
TreeNode treeNode4 = new TreeNode(30);
treeNode.setLeftNote(treeNode1);
treeNode.setRightNote(treeNode2);
treeNode1.setLeftNote(treeNode3);
treeNode1.setRightNote(treeNode4);
treeNode2.setLeftNote(treeNode4);
treeNode2.setRightNote(treeNode3);
boolean duicheng = isDuicheng(treeNode);
System.out.println(duicheng);
}
public static boolean isDuicheng(TreeNode rootNode) {
if (rootNode == null) {
return true;
} else {
return isDuicheng(rootNode.getLeftNote(), rootNode.getRightNote());
}
}
public static boolean isDuicheng(TreeNode left, TreeNode right) {
if (left == null && right == null) {
return true;
} else if (left != null && right == null || left == null && right != null) {
return false;
} else {
return left.getValue() == right.getValue()
&& isDuicheng(left.getLeftNote(), right.getRightNote())
&& isDuicheng(left.getRightNote(), right.getLeftNote());
}
}
}3.图
3.1 概念
在线性表中，数据元素之间是被串联起来的，仅有线性关系，每个数据元素只有一个直接前驱和一个直接后继。在树形结构中，数据元素之间有着明显的层次关系，并且每一层的数据元素可能和下一层中多个元素关联，但只能和上一层中一个元素相关。这和一堆父母可以有多个孩子，但每个孩子只能有一对父母是一个道理。可在现实生活中，人与人之间的关系就非常的复杂，如果我认识的朋友，他们相互之间也互相认识，这就不是简单的一对一，一对多，研究人际关系很自然会考虑多对多的情况。那就是我们今天要研究的另外一种高级数据结构--图。图是一种比线性表和数更加复杂的数据结构。在图形结构中，节点之间的关系可以是任意的，图中任意两个元素之间都有可能相关。
3.2 存储结构
图可以使用两种存储结构，分别是邻接矩阵和邻接表。
邻接矩阵以矩阵的形式存储图所有顶点间的关系。邻接矩阵具有以下特点：
- 1.邻接矩阵是正矩阵，即横纵维数相等。
- 2.矩阵的每一行或一列代表一个顶点，行与列的交点对应这两个顶点的边。
- 3.矩阵的点代表边的属性，1代表有边，0代表无边，所以矩阵的对角线都是0，因为对角线上对应的横纵轴代表相同的顶点，边没有意义。
- 4.如果是无向图，那么矩阵是对称矩阵；如果是有向图则不一定。
- 5.如果是有权图，矩阵点数值可以是权值。
- 6.邻接矩阵表示图的关系非常清晰，但消耗空间较大。
邻接表是以一组链表来表示顶点间关系，有以下特点:
- 1.邻接表示一个有但链表组成的数组
- 2.图中的每一个顶点都有一个链，数组的大小等于图中顶点的个数。
- 3.无向图的链的第一个元素是本顶点，后继分别连接着和这个顶点相连的顶点；有向图的链第一个顶点是本顶点，后继是以本顶点为起点的边的终点。
- 4.如果是有权图，可以在节点元素中设置权值属性
- 5.邻接链表关系表示不如邻接矩阵清晰，数据结构相对复杂，但节省空间。
3.3 图的实现
3.3.1 邻接矩阵无向图
public class MatrixNDG {
int size;//图顶点个数
char[] vertexs;//图顶点名称
int[][] matrix;//图关系矩阵
public MatrixNDG(char[] vertexs,char[][] edges){
size=vertexs.length;
matrix=new int[size][size];//设定图关系矩阵大小
this.vertexs=vertexs;
for(char[] c:edges){//设置矩阵值
int p1 = getPosition(c[0]);//根据顶点名称确定对应矩阵下标
int p2 = getPosition(c[1]);
matrix[p1][p2] = 1;//无向图，在两个对称位置存储
matrix[p2][p1] = 1;
}
}
//图的遍历输出
public void print(){
for(int[] i:matrix){
for(int j:i){
System.out.print(j+" ");
}
System.out.println();
}
}
//根据顶点名称获取对应的矩阵下标
private int getPosition(char ch) {
for(int i=0; i3.3.2 邻接矩阵有向图
public class MatrixDG {
int size;
char[] vertexs;
int[][] matrix;
public MatrixDG(char[] vertexs,char[][] edges){
size=vertexs.length;
matrix=new int[size][size];
this.vertexs=vertexs;
//和邻接矩阵无向图差别仅仅在这里
for(char[] c:edges){
int p1 = getPosition(c[0]);
int p2 = getPosition(c[1]);
matrix[p1][p2] = 1;
}
}
public void print(){
for(int[] i:matrix){
for(int j:i){
System.out.print(j+" ");
}
System.out.println();
}
}
private int getPosition(char ch) {
for(int i=0; i3.3.3 邻接表无向图
public class ListNDG {
Vertex[] vertexLists;//邻接表数组
int size;
class Vertex{//邻接表节点类，单链表数据结构
char ch;
Vertex next;
Vertex(char ch){//初始化方法
this.ch=ch;
}
void add(char ch){//加到链表尾
Vertex node=this;
while(node.next!=null){
node=node.next;
}
node.next=new Vertex(ch);
}
}
public ListNDG(char[] vertexs,char[][] edges){
size=vertexs.length;
this.vertexLists=new Vertex[size];//确定邻接表大小
//设置邻接表头节点
for(int i=0;i3.3.4 邻接表有向图
public class ListDG {
Vertex[] vertexLists;
int size;
class Vertex{
char ch;
Vertex next;
Vertex(char ch){
this.ch=ch;
}
void add(char ch){
Vertex node=this;
while(node.next!=null){
node=node.next;
}
node.next=new Vertex(ch);
}
}
public ListDG(char[] vertexs,char[][] edges){
size=vertexs.length;
this.vertexLists=new Vertex[size];
for(int i=0;i4.小结
现在我们对树和图已经有了一个基本的了解，在后续文章我们将继续讨论他们常用的一些算法。
源码下载地址：https://download.csdn.net/download/geduo_83/10913510
初级篇：Java数据结构与算法初级篇之数组、集合和散列表
中级篇：Java数据结构与算法中级篇之栈、队列、链表
高级篇：Java数据结构与算法高级篇之树、图
理论篇：Java数组、集合、散列表常见算法浅析
理论篇：Java栈、队列、链表常见算法浅析
理论篇：Java树、图常见算法浅析