目录
树的概念及其详解
概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
- 有一个特殊的结点，称为根结点，根结点没有前驱结点
- 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1 <= i <=m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
- 树是递归定义的。
相关概念（重点）
结点的度：一个结点含有子树的个数称为该结点的度
树的度：一棵树中，所有结点度的最大值称为树的度
叶子结点或终端结点：度为0的结点称为叶结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点
根结点：一棵树中，没有双亲结点的结点
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推树的高度或深度：树中结点的最大层次
非终端结点或分支结点：度不为0的结点
兄弟结点：具有相同父结点的结点互称为兄弟结点
堂兄弟结点：双亲在同一层的结点互为堂兄弟
结点的祖先：从根到该结点所经分支上的所有结点
子孙：以某结点为根的子树中任一结点都称为该结点的子孙
森林：由m（m>=0）棵互不相交的树组成的集合称为森林
树的应用
电脑中的文件管理系统
二叉树
概念
一棵二叉树是结点的一个有限集合，该集合：
1. 或者为空
2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
任何二叉树否是由以下几种情况组成的
两种特殊的二叉树
1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
二叉树的性质
- 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有(i>0)2^(i - 1)个结点
- 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是2^k - 1(k>=0)
- 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
- 具有n个结点的完全二叉树的深度k为log2(n + 1)上取整
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：
若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
若2i+1<n，左孩子序号：2i+1，否则无左孩子
若2i+2<n，右孩子序号：2i+2，否则无右孩子
二叉树创建
二叉树的属性定义
private static class TreeNode {
int value; // 当前节点的值
TreeNode left; // 左子树的引用
TreeNode right; // 右子树的引用
// 构造方法
public TreeNode(int value) {
this.value = value;
}
}
// 根节点的引用
public TreeNode root;
一颗树的创建(演示)
public void create () {
// 先所有的节点创建出来
TreeNode node1 = new TreeNode(1);
TreeNode node2 = new TreeNode(2);
TreeNode node3 = new TreeNode(3);
TreeNode node4 = new TreeNode(4);
TreeNode node5 = new TreeNode(5);
TreeNode node6 = new TreeNode(6);
TreeNode node7 = new TreeNode(7);
TreeNode node8 = new TreeNode(8);
// 处理引用关系
node1.left = node2;
node1.right = node3;
node2.left = node4;
node2.right = node5;
node3.left = node6;
node3.right = node7;
// 指定根节点的引用
root = node1;
}
二叉树的遍历
二叉树的遍历方式有四种方式:
NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。
LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。
LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。层序遍历：设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
上图为前序遍历的图解，按照规格进行遍历，中序后序以此类推
例如下图：
前序：F B A D C E G I H
中序：A B C D E F G H I
后序：A C E D B H I G F
层序：F B G A D I C E H
代码实现
遍历(此处递归实现)
//前序遍历
public void preOrder(TreeNode root) {
// 如果是棵空树，直接返回
if(root == null){
return;
}
// 处理根节点
System.out.print(root.value + " ");
// 处理左子树
preOrder(root.left);
//处理右子树
preOrder(root.right);
}
// 中序遍历
public void inOrder(TreeNode root) {
// 如果是棵空树，直接返回
if(root == null){
return;
}
//先处理左孩子
inOrder(root.left);
// 处理根节点
System.out.print(root.value + " ");
//处理右孩子
inOrder(root.right);
}
// 后序遍历
public void postOrder(TreeNode root) {
// 如果是棵空树，直接返回
if(root == null){
return;
}
//处理左子树
postOrder(root.left);
//处理右子树
postOrder(root.right);
// 处理根节点
System.out.print(root.value + " ");
}非递归的前中后序遍历(栈辅助实现)
/**
* 前序遍历
*
*/
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root == null){
return list;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode current = root;
while(current != null || !stack.isEmpty()){
while(current != null){
stack.push(current);
list.add(current.val);
current = current.left;
}
TreeNode top = stack.pop();
current = top.right;
}
return list;
}
/**
* 中序遍历
*
*/
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root == null){
return list;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode current = root;
while(current != null || !stack.isEmpty()){
while(current != null){
stack.push(current);
current = current.left;
}
TreeNode top = stack.pop();
list.add(top.val);
current = top.right;
}
return list;
}
/**
* 后续遍历
*/
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root == null){
return list;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode current = root;
TreeNode prev = null;
while(current != null || !stack.isEmpty()){
while(current != null){
stack.push(current);
current = current.left;
}
TreeNode top = stack.peek();
if(top.right == null || top.right == prev){
list.add(top.val);
stack.pop();
prev = top;
}else{
current = top.right;
}
}
return list;
}层序遍历(队列辅助实现)
public void levelOrder(TreeNode root) {
if(root == null){
return;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
System.out.print(node.value + " ");
if(node.left != null){
queue.offer(node.left);
}
if (node.right != null){
queue.offer(node.right);
}
}
}获取树中节点个数
/**
* 获取树中节点的个数 - 遍历思路
* @param root
* @return
*/
public int size(TreeNode root) {
int count = 1;
if(root == null){
return 0;
}
count += size1(root.left);
count += size1(root.right);
return count;
}获取叶子结点个数
public int leafCount;
/**
* 获取叶子节点的个数 - 遍历
* @param root
* @return
*/
public int getLeafNodeCount1(TreeNode root) {
if(root == null){
return 0;
}
if(root.left == null && root.right == null){
leafCount++;
}
getLeafNodeCount1(root.left);
getLeafNodeCount1(root.right);
return leafCount;
}获取第k层结点个数
public int getKLevelNodeCount(TreeNode root,int k) {
if(root == null || k <= 0){
return 0;
}
if(k == 1){
return 1;
}
int left = getKLevelNodeCount(root.left,k - 1);
int right = getKLevelNodeCount(root.right, k - 1);
return left + right;
}
获取二叉树的高度
public int getHeight(TreeNode root) {
if(root == null){
return 0;
}
int leftDepth = getHeight(root.left);
int rightDepth = getHeight(root.right);
int count = Math.max(leftDepth,rightDepth) + 1;
return count;
}
检测某个元素是否存在
public TreeNode find(TreeNode root, int val) {
if(root == null){
return null;
}
if(root.value == val){
return root;
}
TreeNode leftVal = find(root.left,val);
if(leftVal != null){
return leftVal;
}
TreeNode rightVal = find(root.right,val);
if(rightVal != null){
return rightVal;
}
return null;
}是否为一棵完全二叉树
public boolean isCompleteTree(TreeNode root) {
if(root == null){
return true;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
if(node != null){
queue.offer(node.left);
queue.offer(node.right);
}else{
while (!queue.isEmpty()){
TreeNode checkNode = queue.poll();
if(checkNode != null){
return false;
}
}
}
}
return true;
}
143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
