超级详细树讲解一 —— 二叉树、二叉查找树、完全二叉树图解+代码
首先很高兴你看到了这篇文章，这篇文章可能会花费你很长很长的时间去看，但是这篇文章包括的内容绝对足够你对树的一个系统性的学习。为什么要写这篇文字呢？因为自己在学习树的时候，有些博客只有图解，有些博客只有代码，在这里我将树的图解和代码都整理在了一起。在每个树都有着对应的图解和代码。相信这篇文字会花费你大量的时间，但是绝对值得。
因为全部加在一起太长了，所以分成了三部分去记录：
超级详细树讲解一 —— 二叉树、二叉查找树、完全二叉树图解+代码
超级详细树讲解二 —— 平衡二叉树、哈夫曼树图解+代码
因为博客的排版问题，但是感觉还是比较丑，如果大家想看好看的版本，大家可以前往pdf传送门进行下载。
pdf包含如下树：
代码的github地址：代码传送门
pdf的github地址：pdf传送门
文章目录
树的基本概念
树是数据元素之间具有次层关系的非线性的结构，树是由 n (n>=0) 个节点组成的有限集合。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XtODxkdo-1607097346011)(C:\Users\Auraros\AppData\Roaming\Typora\typora-user-images\image-20201203181745404.png)]](https://img-blog.csdnimg.cn/20201204235703327.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjM0MDAx,size_16,color_FFFFFF,t_70)
- 根节点： 根节点是没有双亲的节点，一棵树中最多只有一个根节点
- 孩子节点：一棵树中，该节点向下延伸的节点，比如A的孩子节点是BCD
- 父母节点：一棵树中，该节点向上延伸的节点，比如BCD的父母节点是A
- 兄弟节点：同为一个父母节点延伸出来的是兄弟节点，BCD是兄弟节点
- 祖先节点：简而言之，父母节点的父母节点…都成为祖先节点，比如E的祖先节点是A
- 叶子节点：没有孩子结点，如同树叶一样，没办法向下延伸
- 节点的度：所有有子树的颗树。A的度为3
二叉树
二叉树的定义
定义：二叉树(Binary Tree) 由一个根节点和两颗互不相交的左右子树的子二叉树构成。每个节点最多只有两个分叉。
特殊的二叉树
-
满二叉树
满二叉树的最大特点是每一层次的结点数都达到最大值
-
完全二叉树
假设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
二叉树首相数据类型
应该实现树应有的：
- 插入
- 删除
- 查找
- 是否包含
- 等
package src.Tree.BinaryTree;
/**
* @Author : Auraros
* @Description :
* @Data : 2020-11-25 2:27
* @Version : 1.0
*/
public interface Tree <T extends Comparable> {
/**
* 判断是否为空
*/
boolean isEmpty();
/**
* 二叉树结点个数
*/
int size();
/**
* 返回二叉树的高度或者深度，即结点的最大层次
*/
int height();
/**
* 前序遍历
*
*/
String preOrder();
/**
* 中序遍历
*
*/
String inOrder();
/**
* 后序遍历
*/
String postOrder();
/**
* 层次遍历
*/
String levelOrder();
/**
* 将data插入
*/
void insert(T data);
/**
* 删除
*/
void remove(T data);
/**
* 查找最大值
*/
T findMax();
/**
* 查找最小值
*/
T findMin();
/**
* 根据值查找到结点
*/
BinaryNode findNode(T data);
/**
* 是否包含某个值
*/
boolean contains(T data);
/**
* 清空
*/
void clear();
}
二叉查找树
背景
为什么不实现二叉树呢？
因为二叉树的插入是没有规则的，所以编写二叉树的接口并没有实际的意义，而且日常生活中并不常用普通二叉树作为数据结构。
定义
二叉查找树的特性是，对于树种的每个结点T（T可能是父结点）,它的左子树中所有项的值小T中的值，而它的右子树中所有项的值都大于T中的值。
二叉查找树代码
二叉查找树节点定义
这意味着该树所有的元素可以用某种规则进行排序(取决于Comparable接口的实现)。二叉查找树使用二叉链表存储结构实现，其结点BinaryNode＜T＞声明如下：
package src.Tree.BinaryTree;
import java.beans.BeanInfo;
/**
* @Author : Auraros
* @Description :
* @Data : 2020-11-25 2:39
* @Version : 1.0
*/
public class BinaryNode<T extends Comparable>{
private static final long serialVersionUID = -6477238039299912313L;
public BinaryNode<T> left; //左节点
public BinaryNode<T> right; //右节点
public T data;
public BinaryNode(T data, BinaryNode left, BinaryNode right){
this.data = data;
this.left = left;
this.right = right;
}
public BinaryNode(T data){
this(data, null, null);
}
/**
* 判断是否为叶子节点
*/
public boolean isLeaf(){
return this.left == null && this.right == null;
}
}
二叉查找树类定义
二叉查找树继承与Tree接口，对Tree接口中的方法实现重写。
package src.Tree.BinaryTree;
import java.beans.BeanInfo;
import java.net.StandardSocketOptions;
import java.util.EmptyStackException;
import java.util.LinkedList;
/**
* @Author : Auraros
* @Description :
* @Data : 2020-11-25 2:44
* @Version : 1.0
*/
public class BinarySearchTree<T extends Comparable> implements Tree<T> {
//根结点
protected BinaryNode<T> root;
public BinarySearchTree(){
root =null;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public int size() {
return 0;
}
@Override
public int height() {
return 0;
}
@Override
public String preOrder() {
return null;
}
@Override
public String inOrder() {
return null;
}
@Override
public String postOrder() {
return null;
}
@Override
public String levelOrder() {
return null;
}
@Override
public void insert(T data) {
}
@Override
public void remove(T data) {
}
@Override
public T findMin() {
return null;
}
@Override
public T findMax() {
return null;
}
@Override
public BinaryNode findNode(T data) {
return null;
}
@Override
public boolean contains(T data) throws Exception {
return false;
}
@Override
public void clear() {
}
}
加下来就是实现该类的全部代码了
二叉查找树的插入
如果节点的值比data大：则往节点的左子树前进
如果节点的值比data小：则往节点的右子树前进
如果节点的值比data一样：不做修改
如果此时节点为空，则插入
代码如下：
@Override
public void insert(T data) {
if (data==null)
throw new RuntimeException("data can\'Comparable be null !");
//插入操作
root=insert(data,root);
}
/**
* 插入操作,递归实现
* @param data
* @param p
* @return
*/
private BinaryNode<T> insert(T data,BinaryNode<T> p){
if(p==null){
p=new BinaryNode<>(data,null,null);
}
//比较插入结点的值，决定向左子树还是右子树搜索
int compareResult=data.compareTo(p.data);
if (compareResult<0){//左
p.left=insert(data,p.left);
}else if(compareResult>0){//右
p.right=insert(data,p.right);
}else {
;//已有元素就没必要重复插入了
}
return p;
}
二叉树的删除
多种情况：
- 如果删除节点是叶子节点，则直接删除
- 如果删除节点拥有一个孩子节点，则父节点指向删除节点的子节点
- 如果要删除的结点q拥有两个孩子结点，则删除策略是用q的右子树的最小的数据替代要被删除结点的数据，并递归删除用于替换的结点(此时该结点已为空)，此时二叉查找树的结构并不会被打乱，其特性仍旧生效。（因为： 右子树的最小结点的数据替换要被删除的结点后可以满足维持二叉查找树的结构和特性，又因为右子树最小结点不可能有左孩子，删除起来也相对简单些。）
-
节点是叶子节点
-
具有一个孩子节点
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FSEnsDXw-1607097346022)(C:\Users\Auraros\AppData\Roaming\Typora\typora-user-images\image-20201203191651606.png)]](https://img-blog.csdnimg.cn/20201204235928123.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjM0MDAx,size_16,color_FFFFFF,t_70)
-
拥有两个孩子节点删除
递归代码如下：
@Override
public void remove(T data) {
if(data==null)
throw new RuntimeException("data can\'Comparable be null !");
//删除结点
root=remove(data,root);
}
/**
* 分3种情况
* 1.删除叶子结点(也就是没有孩子结点)
* 2.删除拥有一个孩子结点的结点(可能是左孩子也可能是右孩子)
* 3.删除拥有两个孩子结点的结点
* @param data
* @param p
* @return
*/
private BinaryNode<T> remove(T data,BinaryNode<T> p){
//没有找到要删除的元素,递归结束
if (p==null){
return p;
}
int compareResult=data.compareTo(p.data);
if (compareResult<0){//左边查找删除结点
p.left=remove(data,p.left);
}else if (compareResult>0) {
p.right=remove(data,p.right);
}else if (p.left!=null&&p.right!=null){//已找到结点并判断是否有两个子结点(情况3)
//中继替换，找到右子树中最小的元素并替换需要删除的元素值
p.data = findMin( p.right ).data;
//移除用于替换的结点
p.right = remove( p.data, p.right );
}else {
//拥有一个孩子结点的结点和叶子结点的情况
p=(p.left!=null)? p.left : p.right;
}
return p;//返回该结点
}
非递归删除
/**
* 非递归删除
* @param data
*/
public T removeUnrecure(T data){
if (data==null){
throw new RuntimeException("data can\'Comparable be null !");
}
//从根结点开始查找
BinaryNode<T> current =this.root;
//记录父结点
BinaryNode<T> parent=this.root;
//判断左右孩子的flag
boolean isLeft=true;
//找到要删除的结点
while (data.compareTo(current.data)!=0){
//更新父结点记录
parent=current;
int result=data.compareTo(current.data);
if(result<0){//从左子树查找
isLeft=true;
current=current.left;
}else if(result>0){//从右子树查找
isLeft=false;
current=current.right;
}
//如果没有找到,返回null
if (current==null){
return null;
}
}
//----------到这里说明已找到要删除的结点
//删除的是叶子结点
if (current.left==null&¤t.right==null){
if (current==this.root){
this.root=null;
} else if(isLeft){
parent.left=null;
}else {
parent.right=null;
}
}
//删除带有一个孩子结点的结点,当current的right不为null
else if (current.left==null){
if (current==this.root){
this.root=current.right;
}else if(isLeft){//current为parent的左孩子
parent.left=current.right;
}else {//current为parent的右孩子
parent.right=current.right;
}
}
//删除带有一个孩子结点的结点,当current的left不为null
else if(current.right==null){
if (current==this.root){
this.root=current.left;
}else if (isLeft){//current为parent的左孩子
parent.left=current.left;
}else {//current为parent的右孩子
parent.right=current.left;
}
}
//删除带有两个孩子结点的结点
else {
//找到当前要删除结点current的右子树中的最小值元素
BinaryNode<T> successor= findSuccessor(current);
if(current == root) {
this.root = successor;
} else if(isLeft) {
parent.left = successor;
} else{
parent.right = successor;
}
//把当前要删除的结点的左孩子赋值给successor
successor.left = current.left;
}
return current.data;
}
/**
* 查找中继结点--右子树最小值结点
* @param delNode 要删除的结点
* @return
*/
public BinaryNode<T> findSuccessor(BinaryNode<T> delNode) {
BinaryNode<T> successor = delNode;
BinaryNode<T> successorParent = delNode;
BinaryNode<T> current = delNode.right;
//不断查找左结点,直到为空,则successor为最小值结点
while(current != null) {
successorParent = successor;
successor = current;
current = current.left;
}
//如果要删除结点的右孩子与successor不相等,则执行如下操作(如果相当,则说明删除结点)
if(successor != delNode.right) {
successorParent.left = successor.right;
//把中继结点的右孩子指向当前要删除结点的右孩子
successor.right = delNode.right;
}
return successor;
}
查找最大和最小值
-
对于findMin()，则需要从根结点开始并且只要有左孩子就向左进行即可，其终止点即为最小值的元素；
-
对于findMax()，也需要从根结点开始并且只要有右孩子就向右进行即可
@Override
public T findMin() {
if(isEmpty())
throw new EmptyTreeException("BinarySearchTree is empty!");
return findMin(root).data;
}
@Override
public T findMax() {
if(isEmpty())
throw new EmptyTreeException("BinarySearchTree is empty!");
return findMax(root).data;
}
/**
* 查找最小值结点
* @param p
* @return
*/
private BinaryNode<T> findMin(BinaryNode<T> p){
if (p==null)//结束条件
return null;
else if (p.left==null)//如果没有左结点,那么t就是最小的
return p;
return findMin(p.left);
}
/**
* 查找最大值结点
* @param p
* @return
*/
private BinaryNode<T> findMax(BinaryNode<T> p){
if (p==null)//结束条件
return null;
else if (p.right==null)
return p;
return findMax(p.right);
}
二叉树的深度
然后计算出左子树的深度和右子树的深度，接着比较左子树与右子树的深度，最后返回深度大的即可。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-azMmIXqZ-1607097346043)(C:\Users\Auraros\AppData\Roaming\Typora\typora-user-images\image-20201203192243385.png)]](https://img-blog.csdnimg.cn/20201205000052610.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjM0MDAx,size_16,color_FFFFFF,t_70)
代码如下：
/**
* 计算深度
* @return
*/
@Override
public int height() {
return height(root);
}
/**
* 递归实现
* @param subtree
* @return
*/
private int height(BinaryNode<T> subtree){
if (subtree==null){
return 0;
}else {
int l=height(subtree.left);
int r=height(subtree.right);
return (l>r) ? (l+1):(r+1);//返回并加上当前层
}
}
求二叉树大小
一层一层找就行
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ar8FW4cb-1607097346050)(C:\Users\Auraros\AppData\Roaming\Typora\typora-user-images\image-20201203192350270.png)]](https://img-blog.csdnimg.cn/20201205000105246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjM0MDAx,size_16,color_FFFFFF,t_70)
代码如下：
/**
* 计算大小
* @return
*/
@Override
public int size() {
return size(root);
}
/**
* 递归实现：定义根节点root后，再用subtree实现递归
* @param subtree
* @return
*/
private int size(BinaryNode<T> subtree){
if (subtree == null)
return 0;
else
{
//对比汉诺塔:H(n)=H(n-1) + 1 + H(n-1)
return size(subtree.left) + 1 + size(subtree.right);
}
}
二叉树的遍历
这个应该不用详细介绍了，刷力扣的题目会经常用到
递归遍历如下：
@Override
public String preOrder() {
String sb = preOrder(root);
if(sb.length() > 0){ //删除尾部的,
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String preOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if (node ==null) {//递归结束条件
return "";
}
//先访问根结点
sb.append(node.data+",");
//遍历左子树
sb.append(preOrder(node.left));
//遍历右子树
sb.append(preOrder(node.right));
return sb.toString();
}
@Override
public String inOrder() {
String sb = inOrder(root);
if(sb.length() > 0){
//删除尾部节点
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String inOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if(node==null){
return "";
}
sb.append(inOrder(node.left));
sb.append(node.data + ",");
sb.append(inOrder(node.right));
return sb.toString();
}
@Override
public String postOrder() {
String sb = postOrder(root);
if(sb.length() > 0){
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String postOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if(node == null){
return "";
}
sb.append(postOrder(node.left));
sb.append(postOrder(node.right));
sb.append(node.data + ",");
return sb.toString();
}
非递归遍历如下：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
public static void preOrderInteration(TreeNode head){
if(head == null){
return;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(head);
while(!stack.isEmpty()){
TreeNode node = stack.pop();
System.out.print(node.val + "");
if(node.right != null){
stack.push(node.right);
}
if(node.left != null){
stack.push(node.left);
}
}
}
public static void inOrderIteration(TreeNode head){
if(head == null){
return;
}
TreeNode cur = head;
Stack<TreeNode> stack = new Stack<>();
while(!stack.isEmpty() || cur != null){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
System.out.print(node.value + " ");
if (node.right != null) {
cur = node.right;
}
}
}
public static void postOrderIteration(TreeNode head) {
if (head == null) {
return;
}
Stack<TreeNode> stack1 = new Stack<>();
Stack<TreeNode> stack2 = new Stack<>();
stack1.push(head);
while (!stack1.isEmpty()) {
TreeNode node = stack1.pop();
stack2.push(node);
if (node.left != null) {
stack1.push(node.left);
}
if (node.right != null) {
stack1.push(node.right);
}
}
while (!stack2.isEmpty()) {
System.out.print(stack2.pop().value + " ");
}
}
还有一种叫Morris算法，在这里就不介绍了
层次遍历代码：
@Override
public String levelOrder() {
LinkedList<BinaryNode<T>> queue = new LinkedList<>();
StringBuffer sb = new StringBuffer();
BinaryNode<T> node = root;
while(node!=null){
sb.append(node.data + ",");
if(node.left!=null){
queue.add(node.left);
}
if(node.right!= null){
queue.add(node.right);
}
node = queue.poll();
}
return sb.toString().substring(0, sb.length()-1);
}
二叉树查找树全部代码
整个代码如下：
package src.Tree.BinaryTree;
import java.beans.BeanInfo;
import java.net.StandardSocketOptions;
import java.util.EmptyStackException;
import java.util.LinkedList;
/**
* @Author : Auraros
* @Description :
* @Data : 2020-11-25 2:44
* @Version : 1.0
*/
public class BinarySearchTree<T extends Comparable> implements Tree<T> {
protected BinaryNode<T> root;
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public int size() {
return size(root);
}
public int size(BinaryNode<T> node){
if(node == null){
return 0;
}else{
return size(node.right) + 1 + size(node.left);
}
}
@Override
public int height() {
return height(root);
}
public int height(BinaryNode<T> node){
if(root == null){
return 0;
}else{
int left = height(node.left);
int right = height(node.right);
return (left - right) > 0 ? left + 1: right + 1; //加上当前层
}
}
@Override
public String preOrder() {
String sb = preOrder(root);
if(sb.length() > 0){ //删除尾部的,
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String preOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if (node ==null) {//递归结束条件
return "";
}
//先访问根结点
sb.append(node.data+",");
//遍历左子树
sb.append(preOrder(node.left));
//遍历右子树
sb.append(preOrder(node.right));
return sb.toString();
}
@Override
public String inOrder() {
String sb = inOrder(root);
if(sb.length() > 0){
//删除尾部节点
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String inOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if(node==null){
return "";
}
sb.append(inOrder(node.left));
sb.append(node.data + ",");
sb.append(inOrder(node.right));
return sb.toString();
}
@Override
public String postOrder() {
String sb = postOrder(root);
if(sb.length() > 0){
sb = sb.substring(0, sb.length()-1);
}
return sb;
}
public String postOrder(BinaryNode<T> node){
StringBuffer sb = new StringBuffer();
if(node == null){
return "";
}
sb.append(postOrder(node.left));
sb.append(postOrder(node.right));
sb.append(node.data + ",");
return sb.toString();
}
@Override
public String levelOrder() {
LinkedList<BinaryNode<T>> queue = new LinkedList<>();
StringBuffer sb = new StringBuffer();
BinaryNode<T> node = root;
while(node!=null){
sb.append(node.data + ",");
if(node.left!=null){
queue.add(node.left);
}
if(node.right!= null){
queue.add(node.right);
}
node = queue.poll();
}
return sb.toString().substring(0, sb.length()-1);
}
@Override
public void insert(T data) {
if(data == null)
throw new RuntimeException("data can\'Comparable be null");
//插入操作
root = insert(data, root);
}
/**
* 插入操作
* @param data
*/
private BinaryNode<T> insert(T data, BinaryNode<T> node){
if(node == null){
node = new BinaryNode<T>(data, null, null);
}
//比较插入节点的值，决定插入方向
int compareResult = data.compareTo(node.data);
if(compareResult < 0){
node.left = insert(data, node.left);
}else if(compareResult > 0){
node.right = insert(data, node.right);
}else{
;//
}
return node;
}
@Override
public void remove(T data) {
if(data == null)
throw new RuntimeException("data can\'Comparable be null");
//删除操作
root = remove(data, root);
}
private BinaryNode<T> remove(T data, BinaryNode<T> node){
if(node == null){
return node;
}
int CompareResult = data.compareTo(node.data);
if(CompareResult < 0){
node.left = remove(data, node.left);
}else if(CompareResult > 0){
node.right = remove(data, node.right);
}else if(node.left != null && node.right != null){ //判断是否有两个子节点
//将要删除的节点用该节点右节点的最小值替换
node.data = findMin(node.right).data;
//移除用于替换的节点
node.right = remove(node.data, node.right);
}else{ //拥有一个孩子节点
node = (node.left != null) ? node.left : node.right;
}
return node;
}
/**
* 非递归删除
* @return
*/
public T removeUnrecure(T data){
if(data == null)
throw new RuntimeException("data can\'Comparable be null !");
//从根节点开始查找
BinaryNode<T> current = this.root;
//记录父节点
BinaryNode<T> parent = this.root;
//判断左右孩子的flag
boolean isLeft = true;
//找到要删除的节点
while( data.compareTo(current.data)!=0){
//更新父节点
parent = current;
int result = data.compareTo(current.data);
if(result < 0){ //从左子树
isLeft = true;
current = current.left;
}else if(result > 0){
isLeft = false;
current = current.right;
}
if(current == null){
return null;
}
}
//找到了要删除的节点
//删除的是叶子节点
if (current.left == null && current.right == null){
if(current == this.root){
this.root = null;
}else if(isLeft){
parent.left= null;
}else{
parent.right = null;
}
}
//删除带有一个孩子的节点，当current的right不为null
else if(current.left == null){
if(current == root){
this.root = current.right;
}else if(isLeft){ //current为parent的左子节点
parent.left = current.right;
}else{
parent.right = current.right;
}
}
//删除带有一个孩子的节点，当current的left不为null
else if (current.right == null){
if(current == root){
this.root = current.left;
}else if(isLeft) {
parent.left = current.left;
}else{
parent.right = current.left;
}
}
//删除两个节点的
else{
//找到当前要删除节点current的右子树中的最小值
BinaryNode<T> successor = finSuccessor(current);
if(current == root){
this.root = successor;
}else if(isLeft){
parent.left = successor;
}else{
parent.right = successor;
}
//把当前要删除的结点的左孩子赋值给successor
successor.left = current.left;
}
return current.data;
}
/**
* 查找右子节点最小值
* @return
*/
public BinaryNode<T> finSuccessor(BinaryNode<T> delNode){
BinaryNode<T> successor = delNode;
BinaryNode<T> successorParent = delNode;
BinaryNode<T> current = delNode.right;
//不断查找左结点,直到为空,则successor为最小值结点
while(current != null) {
successorParent = successor;
successor = current;
current = current.left;
}
//如果要删除结点的右孩子与successor不相等,则执行如下操作(如果相当,则说明删除结点)
if(successor != delNode.right) {
successorParent.left = successor.right;
//把中继结点的右孩子指向当前要删除结点的右孩子
successor.right = delNode.right;
}
return successor;
}
@Override
public T findMax() {
if(isEmpty())
throw new RuntimeException("BinarySearchTree is empty!");
return findMax(root).data;
}
public BinaryNode<T> findMax(BinaryNode<T> node){
if(node == null){
return null;
}if(node.right == null){
return node;
}
return findMax(node.right);
}
@Override
public T findMin() {
if(isEmpty())
throw new RuntimeException("BinarySearchTree is empty!");
return findMin(root).data;
}
/**
* 查找最小值节点
* @param node
* @return
*/
public BinaryNode<T> findMin(BinaryNode<T> node){
if(node == null){
return null;
}else if(node.left == null){ //如果没有左节点
return node;
}
return findMin(node.left);
}
@Override
public BinaryNode findNode(T data) {
BinaryNode res = findNode(data, root);
if (res == null) {
System.out.println("not found");
return new BinaryNode(-1);
} else {
return res;
}
}
public BinaryNode findNode(T data, BinaryNode<T> node){
if(node == null){
return null;
}
int compareResult = data.compareTo(node.data);
//System.out.println(compareResult);
if(compareResult < 0){
findNode(data, node.left);
}else if(compareResult > 0){
findNode(data, node.right);
}else{
return node;
}
return null;
}
@Override
public boolean contains(T data) {
boolean res = contains(data, root);
if (!res) {
System.out.println("not found");
return false;
} else {
return true;
}
}
public boolean contains(T data, BinaryNode<T> node){
if(node == null){
return false;
}
int compareResult = data.compareTo(node.data);
//System.out.println(compareResult);
if(compareResult < 0){
contains(data, node.left);
}else if(compareResult > 0){
contains(data, node.right);
}else{
return true;
}
return false;
}
@Override
public void clear() {
root = null;
}
public static void main(String[] args) {
BinaryNode<Integer> root = new BinaryNode<>(2);
BinarySearchTree<Integer> bTree = new BinarySearchTree<Integer>();
bTree.insert(3);
bTree.insert(4);
bTree.insert(2);
bTree.insert(1);
bTree.remove(3);
System.out.println(bTree.preOrder()); //3,2,1,4
System.out.println(bTree.inOrder()); //1,2,3,4
System.out.println(bTree.postOrder()); //1,2,4,3
System.out.println(bTree.levelOrder()); //3,2,4,1
System.out.println(bTree.findNode(3).data); //-1
System.out.println(bTree.contains(3)); //-1
}
}
完全二叉树
明白了层次遍历算法后，我们可以利用层次遍历算法来构建一棵完全二叉树，为什么是完全二叉树而不是二叉树呢？完全二叉树继承于二叉查找树，可以用层次遍历进行构建。
package src.Tree.BinaryTree;
import java.util.LinkedList;
/**
* @Author : Auraros
* @Description :
* @Data : 2020-11-25 20:29
* @Version : 1.0
*/
public class CompleteBinaryTree<T extends Comparable> extends BinarySearchTree<T>{
/**
* 构造空的完全二叉树
*/
public CompleteBinaryTree(){
super();
}
/**
* 以层次遍历的形式建立完全二叉树
* @param levelOrderArray
*/
public CompleteBinaryTree(T[] levelOrderArray){
this.root = create(levelOrderArray, 0);
}
/**
* 建树
* @param levelOrderArray
* @param i
* @return
*/
public BinaryNode<T> create(T[] levelOrderArray, int i){
if(levelOrderArray ==null){
throw new RuntimeException("the param 'array' of create method can\'t be null !");
}
BinaryNode<T> p = null;
if (i < levelOrderArray.length){//递归结束条件
p=new BinaryNode<>(levelOrderArray[i],null,null);
p.left=create(levelOrderArray,2*i+1); //根据完全二叉树的性质 2*i+1 为左孩子结点
p.right=create(levelOrderArray,2*i+2); //2*i+2 为右孩子结点
}
return p;
}
/**
* 搜索二叉树的包含操作和移除操作不适合层次遍历构造的完全二叉树
* 根据层次遍历构建的二叉树必须用层次遍历来判断(仅适用层次遍历构建的完全二叉树)
* @param data
* @return
*/
@Override
public boolean contains(T data) {
/**
* 存放需要遍历的结点,左结点一定优先右节点遍历
*/
LinkedList<BinaryNode<T>> queue = new LinkedList<>();
StringBuffer sb=new StringBuffer();
BinaryNode<T> p=this.root;
while (p!=null){
//判断是否存在data
if(data.compareTo(p.data)==0){
return true;
}
//先按层次遍历结点,左结点一定在右结点之前访问
if(p.left!=null){
//孩子结点入队
queue.add(p.left);
}
if (p.right!=null){
queue.add(p.right);
}
//访问下一个结点
p=queue.poll();
}
return false;
}
/**
* 搜索二叉树的包含操作和移除操作不适合层次遍历构造的完全二叉树
* @param data
* @return
*/
@Override
public void remove(T data) {
//do nothing 取消删除操作
}
/**
* 完全二叉树只通过层次遍历来构建,取消insert操作
* @param data
*/
@Override
public void insert(T data) {
//do nothing //取消insert操作
}
/**
* 测试
* @param args
*/
public static void main(String args[])
{
String[] levelorderArray = {"A","B","C","D","E","F"};
CompleteBinaryTree<String> cbtree = new CompleteBinaryTree<>(levelorderArray);
System.out.println("先根遍历:"+cbtree.preOrder());
//System.out.println("非递归先根遍历:"+cbtree.preOrderTraverse());
System.out.println("中根遍历:"+cbtree.inOrder());
//System.out.println("非递归中根遍历:"+cbtree.inOrderTraverse());
System.out.println("后根遍历:"+cbtree.postOrder());
//System.out.println("非递归后根遍历:"+cbtree.postOrderTraverse());
System.out.println("查找最大结点(根据搜索二叉树):"+cbtree.findMax());
System.out.println("查找最小结点(根据搜索二叉树):"+cbtree.findMin());
System.out.println("判断二叉树中是否存在E:"+cbtree.contains("E"));
}
}
384
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
