一、树和二叉树
1、什么是树
树(tree)是n(n≥0)个节点的有限集。当n=0时,称为空树。在任意一个非空树中,有如下特点。
1. 有且仅有一个特定的称为根的节点。
2. 当n>1时,其余节点可分为m(m>0)个互不相交的有限集,每一个集合本身又是一个树,并称为根的子树。
没有子节点的节点成为叶子节点(leaf)
节点4的上一级节点,是节点4的父节点(parent);从节点4衍生出来的节点,是节点4的孩子节点(child);和节点4同级,由同一个父节点衍生出来的节点,是节点4的兄弟节点(sibling)
树的最大层级数,被称为树的高度或深度。
2、什么是二叉树
二叉树(binary tree)是树的一种特殊形式。二叉,顾名思义,这种树的每个节点最多有2个孩子节点。注意,这里是最多有2个,也可能只有1个,或者没有孩子节点。
二叉树节点的两个孩子节点,一个被称为左孩子(left child),一个被称为右孩子(right child)。这两个孩子节点的顺序是固定的,就像人的左手就是左手,右手就是右手,不能够颠倒或混淆。
此外,二叉树还有两种特殊形式,一个叫作满二叉树,另一个叫作完全二叉树。
什么是满二叉树呢?
一个二叉树的所有非叶子节点都存在左右孩子,并且所有叶子节点都在同一层级上,那么这个树就是满二叉树。简单点说,满二叉树的每一个分支都是满的。
什么又是完全二叉树呢?
对一个有n个节点的二叉树,按层级顺序编号,则所有节点的编号为从1到n。如果这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同,则这个二叉树为完全二叉树。
完全二叉树的条件没有满二叉树那么苛刻:满二叉树要求所有分支都是满的;而完全二叉树只需保证最后一个节点之前的节点都齐全即可。
二叉树可以用哪些物理存储结构来表达呢?
1. 链式存储结构。
二叉树的每一个节点包含3部分。
存储数据的data变量
指向左孩子的left指针
指向右孩子的right指针
2. 数组。
使用数组存储时,会按照层级顺序把二叉树的节点放到数组中对应的位置上。如果某一个节点的左孩子或右孩子空缺,则数组的相应位置也空出来。
假设一个父节点的下标是parent,那么它的左孩子节点下标就是2×parent + 1;右孩子节点下标就是2×parent + 2。
反过来,假设一个左孩子节点的下标是leftChild,那么它的父节点下标就是(leftChild-1)/ 2。
显然,对于一个稀疏的二叉树来说,用数组表示法是非常浪费空间的。
什么样的二叉树最适合用数组表示呢:二叉堆,一种特殊的完全二叉树
3、二叉树的应用
1.查找:用于索引
二叉查找树(binary search tree)。
二叉查找树在二叉树的基础上增加了以下几个条件。
如果左子树不为空,则左子树上所有节点的值均小于根节点的值
如果右子树不为空,则右子树上所有节点的值均大于根节点的值
左、右子树也都是二叉查找树
对于一个节点分布相对均衡的二叉查找树来说,如果节点总数是n,那么搜索节点的时间复杂度就是O(logn),和树的深度是一样的。
这种依靠比较大小来逐步查找的方式,和二分查找算法非常相似。
2.维持相对顺序
二叉查找树还有另一个名字——二叉排序树(binary sort tree)。
二叉树的自平衡
二、二叉树的遍历
1、为什么需要遍历
在计算机程序中,遍历本身是一个线性操作。所以遍历同样具有线性结构的数组或链表,是一件轻而易举的事情。
反观二叉树,是典型的非线性数据结构,遍历时需要把非线性关联的节点转化成一个线性的序列,以不同的方式来遍历,遍历出的序列顺序也不同。
二叉树的遍历方式:
从节点之间位置关系的角度来看,二叉树的遍历分为4种。
1. 前序遍历。
2. 中序遍历。
3. 后序遍历。
4. 层序遍历。
从更宏观的角度来看,二叉树的遍历归结为两大类。
1. 深度优先遍历(前序遍历、中序遍历、后序遍历)。
2. 广度优先遍历(层序遍历)。
2、深度优先遍历
深度优先和广度优先这两个概念不止局限于二叉树,它们更是一种抽象的算法思想,决定了访问某些复杂数据结构的顺序。在访问树、图,或其他一些复杂数据结构时,这两个概念常常被使用到。
所谓深度优先,顾名思义,就是偏向于纵深,“一头扎到底”的访问方式。可能这种说法有些抽象,下面就通过二叉树的前序遍历、中序遍历、后序遍历,来看一看深度优先是怎么回事吧。
1. 前序遍历
二叉树的前序遍历,输出顺序是根节点、左子树、右子树。
上图就是一个二叉树的前序遍历,每个节点左侧的序号代表该节点的输出顺序,详细步骤如下。
1. 首先输出的是根节点1。
2. 由于根节点1存在左孩子,输出左孩子节点2。
3. 由于节点2也存在左孩子,输出左孩子节点4。
4. 节点4既没有左孩子,也没有右孩子,那么回到节点2,输出节点2的右孩子节5。
5. 节点5既没有左孩子,也没有右孩子,那么回到节点1,输出节点1的右孩子节3。
6. 节点3没有左孩子,但是有右孩子,因此输出节点3的右孩子节点6。
2. 中序遍历
二叉树的中序遍历,输出顺序是左子树、根节点、右子树。
上图就是一个二叉树的中序遍历,每个节点左侧的序号代表该节点的输出顺序,详细步骤如下。
1. 首先访问根节点的左孩子,如果这个左孩子还拥有左孩子,则继续深入访问下去,一直找到不再有左孩子的节点,并输出该节点。显然,第一个没有左孩子的节点是节点4。
2.依照中序遍历的次序,接下来输出节点4的父节点2。
3. 再输出节点2的右孩子节点5。
4. 以节点2为根的左子树已经输出完毕,这时再输出整个二叉树的根节点1。
5. 由于节点3没有左孩子,所以直接输出根节点1的右孩子节点3。
6. 最后输出节点3的右孩子节点6。
3. 后序遍历
二叉树的后序遍历,输出顺序是左子树、右子树、根节点。
上图就是一个二叉树的后序遍历,每个节点左侧的序号代表该节点的输出顺序。
代码实现
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
/**
* @Author: wanglei
* @Description: 二叉树遍历
* @Date Created in 2021-06-29 2:14 下午
*/
public class TestTree {
/**
* 构建二叉树
*
* @param inputList 输入序列
*/
public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
TreeNode node = null;
if (inputList == null || inputList.isEmpty()) {
return null;
}
Integer data = inputList.removeFirst();
if (data != null) {
node = new TreeNode(data);
node.leftChild = createBinaryTree(inputList);
node.rightChild = createBinaryTree(inputList);
}
return node;
}
/**
* 二叉树前序遍历
*
* @param node 二叉树节点
*/
public static void preOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
System.out.println(node.data);
preOrderTraveral(node.leftChild);
preOrderTraveral(node.rightChild);
}
/**
* 二叉树中序遍历
*
* @param node 二叉树节点
*/
public static void inOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
inOrderTraveral(node.leftChild);
System.out.println(node.data);
inOrderTraveral(node.rightChild);
}
/**
* 二叉树后序遍历
*
* @param node 二叉树节点
*/
public static void postOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
postOrderTraveral(node.leftChild);
postOrderTraveral(node.rightChild);
System.out.println(node.data);
}
/**
* 二叉树节点
*/
private static class TreeNode {
int data;
TreeNode leftChild;
TreeNode rightChild;
TreeNode(int data) {
this.data = data;
}
}
public static void main(String[] args) {
LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{3, 2, 9, null, null, 10, null, null, 8, null, 4}));
TreeNode treeNode = createBinaryTree(inputList);
System.out.println(" 前序遍历:");
preOrderTraveral(treeNode);
System.out.println(" 中序遍历:");
inOrderTraveral(treeNode);
System.out.println(" 后序遍历:");
postOrderTraveral(treeNode);
}
}
3、广度优先遍历
如果说深度优先遍历是在一个方向上“一头扎到底”,那么广度优先遍历则恰恰相反:先在各个方向上各走出1步,再在各个方向上走出第2步、第3步……一直到各个方向全部走完。听起来有些抽象,下面让我们通过二叉树的层序遍历,来看一看广度优先是怎么回事。
层序遍历,顾名思义,就是二叉树按照从根节点到叶子节点的层次关系,一层一层横向遍历各个节点。
上图就是一个二叉树的层序遍历,每个节点左侧的序号代表该节点的输出顺序。
可是,二叉树同一层次的节点之间是没有直接关联的,如何实现这种层序遍历呢?
这里同样需要借助一个数据结构来辅助工作,这个数据结构就是队列。
详细遍历步骤如下。
1. 根节点1进入队列。
2. 节点1出队,输出节点1,并得到节点1的左孩子节点2、右孩子节点3。让节点2和节点3入队。
3. 节点2出队,输出节点2,并得到节点2的左孩子节点4、右孩子节点5。让节点4和节点5入队。
4. 节点3出队,输出节点3,并得到节点3的右孩子节点6。让节点6入队。
5. 节点4出队,输出节点4,由于节点4没有孩子节点,所以没有新节点入队。
6. 节点5出队,输出节点5,由于节点5同样没有孩子节点,所以没有新节点入队。
7. 节点6出队,输出节点6,节点6没有孩子节点,没有新节点入队。
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
/**
* @Author: wanglei
* @Description: 二叉树遍历
* @Date Created in 2021-06-29 2:14 下午
*/
public class TestTree {
/**
* 构建二叉树
*
* @param inputList 输入序列
*/
public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
TreeNode node = null;
if (inputList == null || inputList.isEmpty()) {
return null;
}
Integer data = inputList.removeFirst();
if (data != null) {
node = new TreeNode(data);
node.leftChild = createBinaryTree(inputList);
node.rightChild = createBinaryTree(inputList);
}
return node;
}
/**
* 二叉树层序遍历
*
* @param root 二叉树根节点
*/
public static void levelOrderTraversal(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
System.out.println(node.data);
if (node.leftChild != null) {
queue.offer(node.leftChild);
}
if (node.rightChild != null) {
queue.offer(node.rightChild);
}
}
}
/**
* 二叉树节点
*/
private static class TreeNode {
int data;
TreeNode leftChild;
TreeNode rightChild;
TreeNode(int data) {
this.data = data;
}
}
public static void main(String[] args) {
LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{3, 2, 9, null, null, 10, null, null, 8, null, 4}));
TreeNode treeNode = createBinaryTree(inputList);
System.out.println(" 层序遍历:");
levelOrderTraversal(treeNode);
}
}
三、二叉堆
1、什么是二叉堆
二叉堆本质上是一种完全二叉树,它分为两个类型。二叉堆的根节点叫作堆顶。
1. 最大堆:最大堆的任何一个父节点的值,都大于或等于它左、右孩子节点的值。
2. 最小堆:最小堆的任何一个父节点的值,都小于或等于它左、右孩子节点的值。
最大堆和最小堆的特点决定了:最大堆的堆顶是整个堆中的最大元素;最小堆的堆顶是整个堆中的最小元素。
2、二叉堆的自我调整
所谓堆的自我调整,就是把一个不符合堆性质的完全二叉树,调整成一个堆。
对于二叉堆,有如下几种操作(最小堆示例)。
1. 插入节点:当二叉堆插入节点时,插入位置是完全二叉树的最后一个位置,如不符合最小堆性质则让新节点上浮和父接地那交换位置,直到符合规则
2. 删除节点:二叉堆删除节点的过程和插入节点的过程正好相反,所删除的是处于堆顶的节点,这时,为了继续维持完全二叉树的结构,我们把堆的最后一个节点临时补到原本堆顶的位置。如不符合规则则下沉
3. 构建二叉堆:构建二叉堆,也就是把一个无序的完全二叉树调整为二叉堆,本质就是让所有非叶子节点依次“下沉”。经过比较和“下沉”操作,最终每一节点都小于它的左、右孩子节点,一个无序的完全二叉树就被构建成了一个最小堆。
堆的插入和删除操作,时间复杂度确实是O(logn)。构建堆的时间复杂度是O(n)。
四、优先队列
1、优先队列的特点
优先队列不再遵循先入先出的原则,而是分为两种情况。
最大优先队列,无论入队顺序如何,都是当前最大的元素优先出队
最小优先队列,无论入队顺序如何,都是当前最小的元素优先出队
2、优先队列的实现
利用二叉堆来实现
优先队列入队和出队的时间复杂度也是O(logn)
五、小结
什么是树
树是n个节点的有限集,有且仅有一个特定的称为根的节点。当n>1时,其余节点可分为m个互不相交的有限集,每一个集合本身又是一个树,并称为根的子树。
什么是二叉树
二叉树是树的一种特殊形式,每一个节点最多有两个孩子节点。二叉树包含完全二叉树和满二叉树两种特殊形式。
二叉树的遍历方式有几种
根据遍历节点之间的关系,可以分为前序遍历、中序遍历、后序遍历、层序遍历这4种方式;从更宏观的角度划分,可以划分为深度优先遍历和广度优先遍历两大类。
什么是二叉堆
二叉堆是一种特殊的完全二叉树,分为最大堆和最小堆。在最大堆中,任何一个父节点的值,都大于或等于它左、右孩子节点的值。
在最小堆中,任何一个父节点的值,都小于或等于它左、右孩子节点的值。
什么是优先队列
优先队列分为最大优先队列和最小优先队列。在最大优先队列中,无论入队顺序如何,当前最大的元素都会优先出队,这是基于最大堆实现的。
在最小优先队列中,无论入队顺序如何,当前最小的元素都会优先出队,这是基于最小堆实现的。