七、二叉树的基本操作

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量203 收藏 1
点赞数 2
分类专栏： 数据结构与算法 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52297656/article/details/127360396
版权

文章目录

一、基本二叉树

创建节点类型

class HeroNode {
	private int no;
	private String name;
	private HeroNode left; //默认null
	private HeroNode right; //默认null
	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);
	}

前序、中序、后续查找

//前序遍历查找
	/**
	 * @param no 查找no
	 * @return 如果找到就返回该Node ,如果没有找到返回 null
	 */
	public HeroNode preOrderSearch(int no) {
		System.out.println("进入前序查找");
		if(this.no == no) {
			return this;
		}
		//初始化为空
		HeroNode resNode = null;
		//左递归
		if(this.left != null) {
			resNode = this.left.preOrderSearch(no);
		}
		//左递归不为空
		if(resNode != null) {
			return resNode;
		}
		//右递归
		if(this.right != null) {
			resNode = this.right.preOrderSearch(no);
		}
		return resNode;
	}
	
	//中序遍历查找
	public HeroNode infixOrderSearch(int no) {
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.infixOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入中序查找");
		if(this.no == no) {
			return this;
		}
		if(this.right != null) {
			resNode = this.right.infixOrderSearch(no);
		}
		return resNode;
		
	}
	
	//后序遍历查找
	public HeroNode postOrderSearch(int no) {
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.postOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		if(this.right != null) {
			resNode = this.right.postOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入后序查找");
		if(this.no == no) {
			return this;
		}
		return null;
	}

删除节点

//递归删除结点
	//1.如果删除的节点是叶子节点，则删除该节点
	//2.如果删除的节点是非叶子节点，则删除该子树
	public void delNode(int no) {
		if(this.left != null && this.left.no == no) {
			this.left = null;
			return;
		}
		if(this.right != null && this.right.no == no) {
			this.right = null;
			return;
		}
		if(this.left != null) {
			this.left.delNode(no);
		}
		if(this.right != null) {
			this.right.delNode(no);
		}
	}

定义二叉树

class BinaryTree {
	private HeroNode root;

	public void setRoot(HeroNode root) {
		this.root = root;
	}
	
	//删除结点
	public void delNode(int no) {
		if(root != null) {
			//判断root是不是要删除的结点
			if(root.getNo() == no) {
				root = null;
			} else {
				//递归删除
				root.delNode(no);
			}
		}else{
			System.out.println("空树，不能删除");
		}
	}
	//前序遍历
	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("二叉树为空，无法遍历");
		}
	}
	
	//前序查找
	public HeroNode preOrderSearch(int no) {
		if(root != null) {
			return root.preOrderSearch(no);
		} else {
			return null;
		}
	}
	//中序查找
	public HeroNode infixOrderSearch(int no) {
		if(root != null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	//后序查找
	public HeroNode postOrderSearch(int no) {
		if(root != null) {
			return this.root.postOrderSearch(no);
		}else {
			return null;
		}
	}
}

定义主类测试

public class BinaryTreeDemo {

	public static void main(String[] args) {
		//创建一颗二叉树
		BinaryTree binaryTree = new BinaryTree();
		//创建需要的结点
		HeroNode root = new HeroNode(1, "宋江");
		HeroNode node2 = new HeroNode(2, "吴用");
		HeroNode node3 = new HeroNode(3, "卢俊义");
		HeroNode node4 = new HeroNode(4, "林冲");
		HeroNode node5 = new HeroNode(5, "关胜");
		
		//手动创建该二叉树
		root.setLeft(node2);
		root.setRight(node3);
		node3.setRight(node4);
		node3.setLeft(node5);
		binaryTree.setRoot(root);

		System.out.println("前序遍历");
		binaryTree.preOrder();

		System.out.println("中序遍历");
		binaryTree.infixOrder();

		System.out.println("后序遍历");
		binaryTree.postOrder();
		
		//前序查找
		System.out.println("前序查找");
		HeroNode resNode = binaryTree.preOrderSearch(5);
		if (resNode != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//中序查找
		System.out.println("中序查找");
		HeroNode resNode2 = binaryTree.infixOrderSearch(5);
		if (resNode2 != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode2.getNo(), resNode2.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//后序查找
		System.out.println("后序查找");
		HeroNode resNode3 = binaryTree.postOrderSearch(5);
		if (resNode3 != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode3.getNo(), resNode3.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//测试删除结点
		System.out.println("删除前,前序遍历");
		binaryTree.preOrder();
		binaryTree.delNode(5);
		System.out.println("删除后，前序遍历");
		binaryTree.preOrder();
	}

}

代码总结

package com.yzh.tree;
@SuppressWarnings({"all"})
public class BinaryTreeDemo {

	public static void main(String[] args) {
		//创建一颗二叉树
		BinaryTree binaryTree = new BinaryTree();
		//创建需要的结点
		HeroNode root = new HeroNode(1, "宋江");
		HeroNode node2 = new HeroNode(2, "吴用");
		HeroNode node3 = new HeroNode(3, "卢俊义");
		HeroNode node4 = new HeroNode(4, "林冲");
		HeroNode node5 = new HeroNode(5, "关胜");
		
		//手动创建该二叉树
		root.setLeft(node2);
		root.setRight(node3);
		node3.setRight(node4);
		node3.setLeft(node5);
		binaryTree.setRoot(root);

		System.out.println("前序遍历");
		binaryTree.preOrder();

		System.out.println("中序遍历");
		binaryTree.infixOrder();

		System.out.println("后序遍历");
		binaryTree.postOrder();
		
		//前序查找
		System.out.println("前序查找");
		HeroNode resNode = binaryTree.preOrderSearch(5);
		if (resNode != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//中序查找
		System.out.println("中序查找");
		HeroNode resNode2 = binaryTree.infixOrderSearch(5);
		if (resNode2 != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode2.getNo(), resNode2.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//后序查找
		System.out.println("后序查找");
		HeroNode resNode3 = binaryTree.postOrderSearch(5);
		if (resNode3 != null) {
			System.out.printf("找到了，信息为 no=%d name=%s", resNode3.getNo(), resNode3.getName());
		} else {
			System.out.printf("没有找到 no = %d 的英雄", 5);
		}
		
		//测试删除结点
		System.out.println("删除前,前序遍历");
		binaryTree.preOrder();
		binaryTree.delNode(5);
		System.out.println("删除后，前序遍历");
		binaryTree.preOrder();
	}

}

@SuppressWarnings({"all"})
//定义BinaryTree 二叉树
class BinaryTree {
	private HeroNode root;

	public void setRoot(HeroNode root) {
		this.root = root;
	}
	
	//删除结点
	public void delNode(int no) {
		if(root != null) {
			//判断root是不是要删除的结点
			if(root.getNo() == no) {
				root = null;
			} else {
				//递归删除
				root.delNode(no);
			}
		}else{
			System.out.println("空树，不能删除");
		}
	}
	//前序遍历
	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("二叉树为空，无法遍历");
		}
	}
	
	//前序查找
	public HeroNode preOrderSearch(int no) {
		if(root != null) {
			return root.preOrderSearch(no);
		} else {
			return null;
		}
	}
	//中序查找
	public HeroNode infixOrderSearch(int no) {
		if(root != null) {
			return root.infixOrderSearch(no);
		}else {
			return null;
		}
	}
	//后序查找
	public HeroNode postOrderSearch(int no) {
		if(root != null) {
			return this.root.postOrderSearch(no);
		}else {
			return null;
		}
	}
}


@SuppressWarnings({"all"})
//先创建HeroNode 结点
class HeroNode {
	private int no;
	private String name;
	private HeroNode left; //默认null
	private HeroNode right; //默认null
	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 + "]";
	}
	
	//递归删除结点
	//1.如果删除的节点是叶子节点，则删除该节点
	//2.如果删除的节点是非叶子节点，则删除该子树
	public void delNode(int no) {
		if(this.left != null && this.left.no == no) {
			this.left = null;
			return;
		}
		if(this.right != null && this.right.no == no) {
			this.right = null;
			return;
		}
		if(this.left != null) {
			this.left.delNode(no);
		}
		if(this.right != null) {
			this.right.delNode(no);
		}
	}
	
	//前序遍历
	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);
	}
	
	//前序遍历查找
	/**
	 * @param no 查找no
	 * @return 如果找到就返回该Node ,如果没有找到返回 null
	 */
	public HeroNode preOrderSearch(int no) {
		System.out.println("进入前序查找");
		if(this.no == no) {
			return this;
		}
		//初始化为空
		HeroNode resNode = null;
		//左递归
		if(this.left != null) {
			resNode = this.left.preOrderSearch(no);
		}
		//左递归不为空
		if(resNode != null) {
			return resNode;
		}
		//右递归
		if(this.right != null) {
			resNode = this.right.preOrderSearch(no);
		}
		return resNode;
	}
	
	//中序遍历查找
	public HeroNode infixOrderSearch(int no) {
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.infixOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入中序查找");
		if(this.no == no) {
			return this;
		}
		if(this.right != null) {
			resNode = this.right.infixOrderSearch(no);
		}
		return resNode;
		
	}
	
	//后序遍历查找
	public HeroNode postOrderSearch(int no) {
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.postOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		if(this.right != null) {
			resNode = this.right.postOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入后序查找");
		if(this.no == no) {
			return this;
		}
		return null;
	}
	
}

二、顺序存储二叉树

PS：这里只介绍了顺序存储二叉树的前序遍历，读者可自行完成中序和后序的操作

package com.yzh.tree;

public class ArrBinaryTreeDemo {

	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
		ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
		arrBinaryTree.preOrder();
	}

}

//编写一个ArrayBinaryTree, 实现顺序存储二叉树遍历
@SuppressWarnings({"all"})
class ArrBinaryTree {
	private int[] arr;//存储数据结点的数组

	public ArrBinaryTree(int[] arr) {
		this.arr = arr;
	}

	public void preOrder() {
		this.preOrder(0);
	}
	
	//顺序存储二叉树的前序遍历
	/**
	 * @param index 数组的下标 
	 */
	public void preOrder(int index) {
		if(arr == null || arr.length == 0) {
			System.out.println("数组为空");
		}

		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);
		}

	}
	
}
时间邮递员
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树基本操作实验
CS@zeny的博客
11-20 1204
数据结构(实验报告)–二叉树 二叉树的基本操作 实验目的： 理解二叉树的定义 掌握二叉树的链式存储结构 掌握二叉树基本操作的递归算法 实验内容： 先序创建二叉树； 分别实现二叉树的先序、中序、后序递归遍历； 如果将空孩子显示为‘#’,实现二叉树的先序递归遍历 统计二叉树的结点数和叶结点数（写在同一个函数里）； 计算二叉树的深度； 交换二叉树的左右子树； 销毁二叉树。 实验代码 #include <stdio.h> #include <malloc.h&g
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
二叉树所有基本操作
weixin_55858644的博客
01-06 6569
最全的二叉树基本操作
二叉树基本操作实现
qq_43710269的博客
04-16 3529
链式二叉树 数组表示二叉树要求二叉树必须是完全二叉树或者是满二叉树，所以二叉树还可以用链式表示其结构代码如下： typedef int DataType; typedef struct BinaryTree{ struct BinaryTree* _left; struct BinaryTree* _right; DataType data; };BTNode 前序遍历 前序遍历的顺序为根，左子树，右子树，所以也被称为先根遍历。 如图以这个二叉树为例： 这
二叉树基本操作C语言实现
m0_51669674的博客
05-10 3345
一、二叉树的创建 二叉树结构体的定义 typedef char ElemType;//定义数据类型 typedef struct BiNode { ElemType data; struct BiNode* lchild;//左孩子 struct BiNode* rchild;//右孩子 }BiNode,*BiTree; 1、前序递归创建 递归是一种比较难理解的算法，但是既然能递归，就说明有一定的内在规律，所以理解的时候可以简化，把二叉树简化成3个结点，那么创建完A结点，再将左孩子指针作为形参传入就
二叉树基本操作代码
qq_42862882的博客
04-30 5073
import java.io.UnsupportedEncodingException; import java.util.*; public class treeTest { public static void main(String[] args) throws ClassNotFoundException, UnsupportedEncodingException { // ...
二叉树基本操作（16个）
weixin_63003502的博客
04-28 3108
二叉树基本操作（16个）
C语言二叉树基本操作
qq_27638851的博客
08-30 2040
【代码】C语言二叉树基本操作。
二叉树基本操作演示程序C语言编写
qq_59536908的博客
06-17 5151
问题描述：设计一个与二叉树基本操作相关的演示程序要求：开发工具Dev C++ c语言编写1.创建二叉树。2.将创建的二叉树，以树状形式输出。3.分别以先序、中序、后序三种遍历方式访问二叉树。4.输出二叉树中的叶子结点以及叶子结点的个数。5.输出二叉树的高度。.........
线索二叉树基本操作
gaokuiyuan的博客
09-08 1236
线索二叉树的基本操作，包括二叉树的线索化，中序，前序，后序线索二叉树找指定结点p的前驱和后继等代码，运行截图，图解等。
二叉树基本操作_二叉树基本操作_
10-02
实现了基本的二叉树算法，利用链表实现，计算树高，插入删除等
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
二叉树 二叉树_基于C语言实现的二叉树基本操作
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
数据结构二叉树的基本操作，比较基础，初学者专用吧。。。
二叉树的基本操作是什么-以及学习二叉树的基本操作有什么用
04-24
二叉树的基本操作实现
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1916
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 609
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1266
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 417
修改菜品——后端Java
c++ 二叉树基本操作
08-11
二叉树是一种常用的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。...综上所述，二叉树的基本操作主要包括创建、遍历、查找、插入和删除节点。这些操作可以帮助我们对二叉树进行灵活而高效的操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

时间邮递员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值