文章目录
树
为什么需要树这种数据结构
- 数组存储方式的分析
优点:通过下标的方式访问元素,速度快。对于有序数组,还可以使用二分查找提高检索速度
缺点:如果检索某个具体的中,或插入某个值,会整体移动,效率较低
2)链式存储方式的分析
优点:在一定程度上对数组存储方式有优化(比如:插入一个数值节点,只需要将值插入节点,连接到链表中寄了,删除效率也很好)
缺点:在进行检索时,效率很低(比如检索某个值,需要从头结点开始遍历)
(3)树存储方式的分析
能提高数据存储,读取的效率,比如利用二叉树排序,既可以保证数据的检索速度,同时也可以保证数据的插入,删除,修改速度。
树的基础概念
- 节点:一个一个小圆圈,就是对象
- 根节点:没有父节点,最上面的节点
- 父节点:A是B、C的父节点
- 子节点
- 叶子节点:没有子节点的节点(
- 节点的权:节点的值
- 路径:(从根节点找到该节点的路线)
- 层:位于同一个
- 子树:
- 树的高度(最大层数)
- 森林:多棵子树构成
二叉树
二叉树的概念
- 树有很多种,每个节点最多只有两个子节点的一种形式成为二叉树
- 二叉树的子节点分为左节点和右节点
- 如果该二叉树的所有叶子节点都在最后一层,并且节点总数=2^n-1,n为层数,则我们称为满二叉树
- 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层,而且最后一层的叶子节点在左边连续,倒数第二层的叶子节点在右边连续,我们称为完全二叉树
二叉树的遍历
前序遍历:==先输出父节点,==再遍历左子树和右子树
中序遍历:先遍历左子树,再输出父节点,最后遍历右子树
后序遍历:先遍历左子树,再遍历右子树,最后输出父节点.L;5
小结:看输出父节点的顺序,就确定是前序,中序还是后序
前序遍历
前序遍历:==先输出父节点,==再遍历左子树和右子树
创建一颗二叉树
前序遍历
2.1、先输出当前节点(初始时为root节点)
2.2、如果左子节点不为空,递归继续前序遍历
2.3、如果右子节点不为空,则递归继续前序遍历
//编写前序遍历方法
public void preOrder(){
System.out.println(this);//先输出父节点
//递归向左子树前序遍历
if(this.left!=null){
this.left.preOrder();
}
//递归遍历右子树前序遍历
if(this.right!=null){
this.right.preOrder();
}
}
中序遍历
中序遍历:先遍历左子树,再输出父节点,最后遍历右子树
1.创建一颗二叉树
- 中序遍历
2.1、如果当前节点的左子节点不为空,则递归中序遍历
2.2、输出当前节点
2.3、如果当前节点的右子节点不为空,则递归进行中序遍历
//中序遍历
public void infixOrder(){
//递归左子树中序遍历
if(this.left!=null){
this.left.infixOrder();
}
//输出父节点
System.out.println(this);
//递归遍历右子树
if(this.right!=null){
this.right.infixOrder();
}
}
后序遍历
后序遍历:先遍历左子树,再遍历右子树,最后输出父节点
创建一颗二叉树
后序遍历
2.1、如果当前节点的左子节点不为空,则递归后序遍历
2.2、如果当前节点的右子节点不为空,则递归进行后序遍历
2.3、输出当前节点
//后序遍历
public void postOrder(){
//递归后序遍历左子树
if(this.left!=null){
this.left.postOrder();
}
//递归后序遍历右子树
if(this.right!=null){
this.right.postOrder();
}
//输出当前节点
System.out.println(this);
}
代码
package I树的基础;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/1/6 0006 11:11
*/
public class BinaryTreeDemo {
public static void main(String[] args) {
//现需要创建一颗二叉树
BinaryTree binaryTree = new BinaryTree();
//需要创建即可HeroNode节点
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,"关胜");
//说明,我们先手动创建二叉树,后面我们学习递归的方式创建二叉树
binaryTree.setRoot(root);
root.setLeft(heroNode2);
root.setRight(heroNode3);
heroNode3.setRight(heroNode4);
heroNode3.setLeft(heroNode5);
//测试,前序遍历
System.out.println("前序遍历");
binaryTree.preOrder();//1 2 3 5 4
//中序遍历
System.out.println("中序遍历");
binaryTree.infixOrder();//中序遍历2 1 5 3 4
//后序遍历
System.out.println("后序遍历");
binaryTree.postOrder();//2 5 4 3 1
}
}
//定义BinaryTree 二叉树
class BinaryTree{
//根节点
private HeroNode root;
public HeroNode getRoot() {
return root;
}
public void setRoot(HeroNode root) {
this.root = root;
}
public BinaryTree() {
}
//前序遍历
public void preOrder(){
if(this.root!=null){
this.root.preOrder();
}else{
System.out.println("二叉树为空无法遍历");
}
}
//中序遍历
public void infixOrder(){
if(this.root!=null){
this.root.infixOrder();
}else{
System.out.println("二叉树为空无法遍历");
}
}
//后序遍历
public void postOrder(){
if(this.root!=null){
this.root.postOrder();
}else{
System.out.println("二叉树为空无法遍历");
}
}
}
//先创建HeroNode
class HeroNode{
private int no;
private String name;
private HeroNode left;
private HeroNode right;
public HeroNode(int no, String name) {
this.no = no;
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HeroNode getLeft() {
return left;
}
public void setLeft(HeroNode left) {
this.left = left;
}
public HeroNode getRight() {
return right;
}
public void setRight(HeroNode right) {
this.right = right;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
//编写前序遍历方法
public void preOrder(){
System.out.println(this);//先输出父节点
//递归向左子树前序遍历
if(this.left!=null){
this.left.preOrder();
}
//递归遍历右子树前序遍历
if(this.right!=null){
this.right.preOrder();
}
}
//中序遍历
public void infixOrder(){
//递归左子树中序遍历
if(this.left!=null){
this.left.infixOrder();
}
//输出父节点
System.out.println(this);
//递归遍历右子树
if(this.right!=null){
this.right.infixOrder();
}
}
//后序遍历
public void postOrder(){
//递归后序遍历左子树
if(this.left!=null){
this.left.postOrder();
}
//递归后序遍历右子树
if(this.right!=null){
this.right.postOrder();
}
//输出当前节点
System.out.println(this);
}
}
二叉树删除节点
要求
- 如果删除的节点时叶子节点,则删除该节点
- 如果删除的是非叶子节点,则删除该子树
- 测试,删除5号叶子节点和3号子树
思路
- 考虑树如果是空树,如果只有一个root节点,则等价将二叉树置空
- 因为我们的二叉树是单向的,所以我们是判断当前节点的子节点是否需要删除节点,而不能去判断当钱包这个节点是不是需要删除结点。
- 判断如果当前节点的左子节点不为空,并且左子节点就是要删除的节点,就将 this.left = null;并且返回(结束递归删除)
- 判断如果当前节点的右子节点不为空,并且右子节点就是要删除的节点,就将 this.right= null;并且返回(结束递归删除)
- 如果第二部第三部都没有删除节点,那么我们就需要向左子树递归删除;
- 如果第4步也没有删除节点,则应当向右子树进行递归删除
代码
//在树中的方法
//递归删除节点
//1、删除的节点时叶子节点,则删除该节点
//2、如果删除的节点是非叶子节点,则删除该子树
public void deleteNode(int no){
if(root!=null){
//如果只有一个root节点,这里立即判断root是不是就是要删除的节点
if(root.getNo()==no){
root = null;
}else{
root.deleteNode(no);
}
}else{
System.out.println("空树不能删除");
}
}
//在HeroNode类中的方法
public void deleteNode(int no){
//判断如果当前节点的左子节点不为空,并且左子节点就是要删除的节点,就将 this.left = null;并且返回(结束递归删除)
if((this.left!=null)&&(this.left.no==no)){
this.left=null;
return;
}
//判断如果当前节点的右子节点不为空,并且右子节点就是要删除的节点,就将 this.right= null;并且返回(结束递归删除)
if((this.right!=null)&&(this.right.no==no)){
this.right=null;
return;
}
//向左子节点递归删除
if(this.left!=null) {
this.left.deleteNode(no);
}
//向右子节点递归删除
if(this.right!=null) {
this.right.deleteNode(no);
}
}
补充
/*
如果要删除的节点是非叶子节点,现在我们不希望将该非叶子节点为根节点的子树删除,需要指定规则,假如规则如下:
如果该非叶子节点A只有一个子节点B,则子节点B代替节点A
如果该非叶子节点A有左子节点和右子节点C,则让左子节点B代替A
*/
顺序存储二叉树(应用实例:堆排序)
基本概念
从数据存储来看,数组存储方式和树的存储方式可以相互转换,即数组可以转化成树,树也可以转换成数组
要求:
- 二叉树以二叉树的节点,要求以数组的方式来存放[1,2,3,4,5,6,6]
- 要求在遍历数组arr时,仍然可以以前序遍历,对中序遍历和后序遍历的方式完成节点的遍历
顺序存储二叉树的特点
- 顺序二叉树通常只考虑完全二叉树
- 第n个元素的左子节点为2*n+1
- 第n个元速的右3子节点为2*n+2
- 第n个元素的父节点为(n-1)/2
- n:表示二叉树中的第几个元素(按0开始编号)
代码
package I树的基础;
/**
* @Author Zhou jian
* @Date 2020 ${month} 2020/1/7 0007 11:47
* 以数组的方式存储二叉树 并实现遍历
*/
public class ArrayBinaryTreeDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
//创建ArrayBinaryTree
ArrayBinarTree arrayBinarTree = new ArrayBinarTree(arr);
//前序遍历
// arrayBinarTree.preOrder(0);
//中序Bianca
arrayBinarTree.middleOrder(0);
}
}
//编写一个ArrayBinaryTree,实现顺序存储二叉树比那里
class ArrayBinarTree{
private int[] arr;//存储数据节点的数组
public ArrayBinarTree(int[] arr) {
this.arr = arr;
}
//编写方法,完成顺序存储二叉树的前序遍历
/**
* 表示数组的下标
* @param index
*/
public void preOrder(int index){
//如果数组为空或者arr.length==0
if(arr==null||arr.length==0){
System.out.println("数组为空,不能按照二叉树的前序遍历");
}else{
//输出当前元素
System.out.println(arr[index]);
//向左递归遍历
if(index*2+1<arr.length){
preOrder(2*index+1);
}
//想右递归遍历
if((index*2+2)<arr.length){
preOrder(2*index+2);
}
}
}
//中序遍历
public void middleOrder(int index){
//如果数组为空或者arr.length==0
if(arr==null||arr.length==0){
System.out.println("数组为空,不能按照二叉树的前序遍历");
}else{
//向左递归遍历
if(index*2+1<arr.length){
preOrder(2*index+1);
}
//输出当前元素
System.out.println(arr[index]);
//想右递归遍历
if((index*2+2)<arr.length){
preOrder(2*index+2);
}
}
}
}
线索化二叉树
基本介绍
- n个节点的二叉链表中含有n+1(公式2n-(n-1)=n+1)个空指针域。利用二叉链表中的空指针域,存放指向该节点在某种遍历次序下的前驱和后继节点的指针(这种附加的指针称为线索)
- 这种加上了线索的二叉链表称为 线索链表,相应的二叉树称为 线索二叉树。根据线索性质的不同,线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
- 一个节点的前一个节点称为前驱节点
- 一个节点的后一个节点,称为后继节点
思路
创建线索二叉树
//定义ThreadBinaryTree 实现了线索化功能的二叉树
class ThreadBinaryTree{
private HerNode root;
//为了实现线索化,需要创建指向当前节点前驱节点的引用的指针
//在递归进行线索化时,prev总是保留前一个节点
private HerNode prev;
public HerNode getRoot() {
return root;
}
//编写对二叉树中线索化的方法
/**
*
* @param node 就是当前需要线索化节点
*/
public void threadedNodes(HerNode node){
//如果node==null,就不能线索化
if(node==null){
return;
}
//中序线索化
//先线索化左子树
threadedNodes(node.getLeft());
//然后线索化当前节点
//先处理当前节点前驱节点
//以8节点的.left=null,8节点.leftType=
if(node.getLeft()==null){
//让当前节点的左指针指向前驱节点
node.setLeft(prev);
//修改当前节点的做指针的类型
node.setLeftType(1);
}
//处理后继节点
if((prev!=null)&&(prev.getRight()==null)){
//让前驱节点的右指针指向当前节点
prev.setRight(node);
//修改前驱节点的右子帧类型
prev.setRightType(1);
}
//!!!每处理一个节点后,让当前节点是下一个节点的前驱节点
prev = node;
//再线索化右子树
threadedNodes(node.getRight());
}
public void setRoot(HerNode root) {
this.root = root;
}
//前序遍历
public void preOrder(){
if(root!=null){
root.preOrder();
}else{
System.out.println("当前树为空");
}
}
//中序遍历
public void middleOrder(){
if(this.root!=null){
this.root.middleOrder();
}else{
System.out.println("树为空");
}
}
public void postOrder(){
if(this.root!=null){
this.root.postOrder();
}else{
System.out.println("树为空");
}
}
public void deleteNode(int no){
if(root==null){
System.out.println("树为空");
}else if(root.getId()==no){
root =null;
}else{
root.deleteNode(no);
}
}
}
遍历线索二叉树
当线索化二叉树后,不能使用原来的方法,
因为线索化后,各个节点指向有变化,因此原来的遍历方式不能使用,
这时需要使用新的方式遍历线索化二叉树,各个节点可以通过线性方式遍历,
因此无需使用递归方式,这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致
//遍历线索化二叉树的方法
public void threadList(){
//定义一个变量,存储当前遍历的节点,从root开始
HerNode node = root;
while(node!=null){
//循环找到leftType==1的节点,第一个找到的就是8节点
//后面随着遍里而变化,因为当leftTtype==1时,说明该节点是按照
//线索化处理后的有效节点
while(node.getLeftType()==0){
node=node.getLeft();
}
//打印当前节点
System.out.println(node);
//如果当前节点的有指针指向的是后继节点,就一直输出
while(node.getRightType()==1){
//获取当前节点的后继节点
node = node.getRight();
System.out.println(node);
}
//替换这个遍历的节点
node = node.getRight();
}
}
正月15 册总生日