Java 前序中序后序遍历二叉树&查找二叉树的代码实现

最新推荐文章于 2023-06-26 18:34:42 发布
最新推荐文章于 2023-06-26 18:34:42 发布
阅读量423 收藏 1
点赞数 1
分类专栏： 数据结构与算法 Java学习 文章标签： Java 二叉树 遍历 查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38036210/article/details/100171897
版权

1.二叉树的概念

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
  2. 二叉树的子节点分为左节点和右节点。
  3. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
  4. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
  5. 树的遍历
    前序遍历: 先输出父节点，再遍历左子树和右子树
    中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
    后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
    小结: 看输出父节点的顺序，就确定是前序，中序还是后序
  6. 树的查找——查找指定节点
    前序查找：先比较父节点，再遍历左子树和右子树
    中序查找：先遍历左子树，再比较父节点，再遍历右子树
    后序查找：先遍历左子树，再遍历右子树，最后比较父节点

2.前序中序后序遍历二叉树

2.1前序遍历
1.先输出当前节点（初始时是root节点）
2.如果左子节点不为空,则递归继续前序遍历
3.如果右子节点不为空，则递归继续前序遍历

//前序遍历
//1.先输出当前节点（初始时是root节点）
//2.如果左子节点不为空,则递归继续前序遍历
//3.如果右子节点不为空，则递归继续前序遍历
public void preOrder(){
	System.out.println(this);
	if(this.left!=null){
		this.left.preOrder();
	}
	if(this.right!=null){
		this.right.preOrder();
	}
}

2.2中序遍历
1.如果左子节点不为空,则递归继续中序遍历
2.输出当前节点
3.如果右子节点不为空，则递归继续中序遍历

//中序遍历
//1.如果左子节点不为空,则递归继续中序遍历
//2.输出当前节点
//3.如果右子节点不为空，则递归继续中序遍历
public void infixOrder(){
	if(this.left!=null){
		this.left.infixOrder();
	}
	System.out.println(this);
	if(this.right!=null){
		this.right.infixOrder();
	}
}

2.3后序遍历
1.如果左子节点不为空,则递归继续后序遍历
2.如果右子节点不为空，则递归继续后序遍历
3.输出当前节点

//后序遍历
//1.如果左子节点不为空,则递归继续后序遍历
//2.如果右子节点不为空，则递归继续后序遍历
//3.输出当前节点
public void postOrder(){
	if(this.left!=null){
		this.left.postOrder();
	}
	if(this.right!=null){
		this.right.postOrder();
	}
	System.out.println(this);
}

3.前序中序后序查找二叉树

3.1前序查找
1.判断当前结点是否为要查找的结点,如果相等，返回
2.判断左子树是否为空，如果不为空，则递归前序查找
3.判断右子树是否为空，如果不为空，则递归前序查找

//前序查找
//1.判断当前结点是否为要查找的结点,如果相等，返回
//2.判断左子树是否为空，如果不为空，则递归前序查找
//3.判断右子树是否为空，如果不为空，则递归前序查找
public Node preSearch(int val){
	Node resNode=null;
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.preSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.preSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//若未查找到，返回空
	return null;
}

3.2中序查找
1.判断左子树是否为空，如果不为空，则递归中序查找
2.判断当前结点是否为要查找的结点,如果相等，返回
3.判断右子树是否为空，如果不为空，则递归中序查找

//中序查找
//1.判断左子树是否为空，如果不为空，则递归中序查找
//2.判断当前结点是否为要查找的结点,如果相等，返回
//3.判断右子树是否为空，如果不为空，则递归中序查找
public Node infixSearch(int val){
	Node resNode=null;
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.infixSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.infixSearch(val);
	}
	//如果在右子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//若未查找到，返回空
	return null;
}

3.3后序查找
1.判断左子树是否为空，如果不为空，则递归后序查找
2.判断右子树是否为空，如果不为空，则递归后序查找
3.判断当前结点是否为要查找的结点,如果相等，返回

//后序查找
//1.判断左子树是否为空，如果不为空，则递归后序查找
//2.判断右子树是否为空，如果不为空，则递归后序查找
//3.判断当前结点是否为要查找的结点,如果相等，返回
public Node postSearch(int val){
	Node resNode=null;
	//在左子树查找
	if(this.left!=null){
		resNode=this.left.postSearch(val);
	}
	//如果在左子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//在右子树查找
	if(this.right!=null){
		resNode=this.right.postSearch(val);
	}
	//如果在右子树找到，返回
	if(resNode!=null){
		return resNode;
	}
	//判断当前结点
	if(this.val==val){
		return this;
	}
	//若未查找到，返回空
	return null;
}

4.具体实现

//定义BinaryTree 二叉树
class BinaryTree{
	private Node root;       //根节点

	public Node getRoot() {
		return root;
	}

	public void setRoot(Node root) {
		this.root = root;
	}
	
	//前序遍历
	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 Node preSearch(int val){
		if(this.root!=null){
			return this.root.preSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//中序查找
	public Node infixSearch(int val){
		if(this.root!=null){
			return this.root.infixSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//后序查找
	public Node postSearch(int val){
		if(this.root!=null){
			return this.root.postSearch(val);
		}
		else{
			System.out.println("当前二叉树为空，无法遍历");
			return null;
		}
	}
	
	//删除结点
	public void delNode(int val){
		if(this.root!=null){
			//如果删除的结点是根结点
			if(this.root.getVal()==val){
				this.root=null;
			}
			else{
				this.root.delNode(val);
			}
		}
		else{
			System.out.println("树为空，不能删除");
		}
	}
}

//创建Node结点
class Node{
	private int val;
	private Node left;
	private Node right;
	//构造器
	public Node(int val) {
		super();
		this.val = val;
	}
	public int getVal() {
		return val;
	}
	public void setVal(int val) {
		this.val = val;
	}
	public Node getLeft() {
		return left;
	}
	public void setLeft(Node left) {
		this.left = left;
	}
	public Node getRight() {
		return right;
	}
	public void setRight(Node right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "Node [val=" + val + "]";
	}
	
	//前序遍历
    //1.先输出当前节点（初始时是root节点）
    //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.输出当前节点
	//3.如果右子节点不为空，则递归继续中序遍历
	public void infixOrder(){
		if(this.left!=null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right!=null){
			this.right.infixOrder();
		}
	}
	
	//后序遍历
	//1.如果左子节点不为空,则递归继续后序遍历
	//2.如果右子节点不为空，则递归继续后序遍历
	//3.输出当前节点
	public void postOrder(){
		if(this.left!=null){
			this.left.postOrder();
		}
		if(this.right!=null){
			this.right.postOrder();
		}
		System.out.println(this);
	}
	
	//前序查找
	//1.判断当前结点是否为要查找的结点,如果相等，返回
	//2.判断左子树是否为空，如果不为空，则递归前序查找
	//3.判断右子树是否为空，如果不为空，则递归前序查找
	public Node preSearch(int val){
		Node resNode=null;
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.preSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.preSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//若未查找到，返回空
		return null;
	}
	
	//中序查找
	//1.判断左子树是否为空，如果不为空，则递归中序查找
	//2.判断当前结点是否为要查找的结点,如果相等，返回
	//3.判断右子树是否为空，如果不为空，则递归中序查找
	public Node infixSearch(int val){
		Node resNode=null;
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.infixSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.infixSearch(val);
		}
		//如果在右子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//若未查找到，返回空
		return null;
	}
	
	//后序查找
	//1.判断左子树是否为空，如果不为空，则递归后序查找
	//2.判断右子树是否为空，如果不为空，则递归后序查找
	//3.判断当前结点是否为要查找的结点,如果相等，返回
	public Node postSearch(int val){
		Node resNode=null;
		//在左子树查找
		if(this.left!=null){
			resNode=this.left.postSearch(val);
		}
		//如果在左子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//在右子树查找
		if(this.right!=null){
			resNode=this.right.postSearch(val);
		}
		//如果在右子树找到，返回
		if(resNode!=null){
			return resNode;
		}
		//判断当前结点
		if(this.val==val){
			return this;
		}
		//若未查找到，返回空
		return null;
	}
	
	//递归删除结点
	//1.判断当前结点的左右结点是否满足删除条件,若满足,删除，return
	//2.若左结点不为空，递归删除左子树
	//3.若右结点不为空，递归删除右子树
	public void delNode(int val){
		//如果左子节点不为空且满足删除条件
		if(this.left!=null&&this.left.val==val){
			this.left=null;
			return;
		}
		//如果右子节点不为空且满足删除条件
		if(this.right!=null&&this.right.val==val){
			this.right=null;
			return;
		}
		//如果没有找到，下一层递归删除（左子树，右子树）
		if(this.left!=null){
			this.left.delNode(val);
		}
		if(this.right!=null){
			this.right.delNode(val);
		}
	}
}
BayMax_39
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现二叉树的前、中、后序遍历和前序查找
wanglj的博客
06-10 430
二叉树定义类，通过根节点实现二叉树的索引: package cn.tree.test; import cn.tree.java.*; public class BinaryTree { Node root; //设置根节点 public void setRoot(Node root) { this.root = root; } //获取根节点 public Node getRoot() { return root; } //前序 public void frontShow()
Java实现前序、中序、后序线索化二叉树及遍历
weixin_44963741的博客
03-19 1901
1.1 前序线索化二叉树 public void turnToPre(ThreadedNode temp) { if(temp == null) { return ; } if(temp.left == null) { temp.left = pre; temp.leftType = true; } if(pre != null && pre.right ==...
二叉树的先序遍历（源代码）
勤天下而拥家
05-17 9481
1.先序遍历要点： ⑴ 访问根结点； ⑵ 遍历左子树； ⑶ 遍历右子树。 例子：如下图,先序遍历方式结果输出为：ABDECF 代码实现（递归版）： void preOrder1(BinTree *root) //递归前序遍历 { if(root!=NULL) { cout<<root->data<<" "; preOrder
算法数据结构基础——二叉树的遍历（前序、中序、后序、层序）及python实现
白话机器学习
06-05 6883
二叉树的遍历：指的是从根节点出发，按照某种次序依次访问二叉树中所有节点，使得每个节点被访问一次且仅被访问一次。在二叉树的一些实际问题中，经常需要按照一定顺序对二叉树中每个节点逐个进行访问一次，用以查找具有某一特点的节点或者全部节点，然后对这些满足要求的节点进行处理。这里所说的「访问」就是指对该节点进行某种操作，例如：依次输出节点的数据信息、统计满足某条件的节点总数等等。回顾二叉树的递归定义可以知道，二叉树是由根节点和左子树、右子树构成的。因此，如果能依次遍历这3个部分，就可以遍历整个二叉树。
二叉树的遍历c++代码实现
KFLING的博客
06-12 1万+
二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。二叉树的遍历方式常用的有四种：前序遍历、中序遍历、后序遍历和层序遍历。二叉树结点的定义代码如下：//Definition for binary tree struct TreeNode { int val; TreeNode *left; TreeNode *right...
一文搞懂---先序遍历二叉树（内含完整实现代码）
qq_40077565的博客
05-12 2万+
如何用代码实现先序遍历二叉树（C语言或C++） 想必有很多小伙伴和我一样，最开始的时候在网上或者是书上看了一系列有关于二叉树的遍历原理以及递归、非递归的实现方法，但是奈何书中也只是给出了伪代码之类的，并没有一套完整的代码去实现，想自己动手但是还是有点难度，不要担心，小编总结了一个代码，已经在VS2017上调试过了，不过在正式看代码前，让我们先来看几幅图，考考看官们是否理解了先序遍历，如果没有理解原理的话，建议先去看看这位博主的文章： 看懂二叉树的三种遍历 以下三幅图的先序遍历应该是什么顺序，您能写出来吗？
C++实现二叉树三种遍历方法
qq_40624616的博客
03-14 8242
文章目录前序遍历--递归中序遍历--递归后序遍历--递归 前序遍历–递归 文中的二叉树结构如下： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode* le
java 实现的二叉树前序建树，中序建树，后序建树以及前序遍历，中序遍历和后序遍历的代码
01-20
本文将深入探讨如何使用Java实现二叉树的前序、中序和后序建树，以及对应的遍历方法。 首先，我们需要定义一个二叉树节点类`TreeNode`，它包含两个属性：一个整型值`val`表示节点的值，以及两个指向子节点的引用`...
已知二叉树的前序和中序遍历，打印后序遍历
03-26
这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -> 右子树 **中序遍历**：左子树 -> 根节点 -> 右子树 **后序遍历**：左子树 -> 右子...
根据二叉树前序遍历和中序遍历的结果输出后序遍历(java)
04-11
二叉树的遍历是对其进行操作和理解的关键部分，主要包括前序遍历、中序遍历和后序遍历。本话题将详细探讨如何根据给定的二叉树前序遍历和中序遍历的结果，利用Java来输出其后序遍历的序列。 前序遍历的顺序是：根...
二叉树的初始化及应用：二叉树的插入，删除，二叉树的前序后序遍历
最新发布
05-20
二叉树的遍历主要包括前序遍历、中序遍历和后序遍历。 1. **前序遍历**：先访问根节点，再遍历左子树，最后遍历右子树。 2. **后序遍历**：先遍历左子树，再遍历右子树，最后访问根节点。 例如，前序遍历的递归...
详解java实现遍历二叉树的三种情况
08-30
总结来说，Java中遍历二叉树的方法主要有前序、中序、后序以及层次遍历，其中层次遍历又包括正常层次遍历和之字形层次遍历。这些遍历方法都是二叉树算法设计中的基础，理解和掌握它们有助于解决各种复杂的问题。
二叉树遍历方法——前、中、后序遍历（java）
热门推荐
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
LeetCode OJ - Binary Tree Preorder Traversal
姥姥教我学编程
05-11 594
Binary Tree Preorder Traversal  Total Accepted: 17759 Total Submissions: 51092My Submissions Given a binary tree, return the preorder traversal of its nodes' values. For example: Given b
二叉树的前序遍历
CV前沿
04-03 3万+
二叉树的前序遍历的记忆法则是“根左右"，即先遍历根节点，再遍历左子树节点，再遍历右子树节点。 以上图为例，前序遍历的结果是【A, B, D, E, C, F, G】 一、解题思路：递归 递归是我们实现前中后序遍历最常用的方法。 什么问题可以采用递归求解呢？ 需要满足三个条件： 一个问题的解可以分解为若干个子问题的解； 这个问题与分解的子问题，除了数据规模不同外，求解思路相同 存在递归终止条件。 那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？ 关键在于能写出递归公式，找到终止条件。 在.
leetcode：144.二叉树的前序遍历
Rebbeca_tang的博客
03-16 130
题目：144.二叉树的前序遍历 代码来源： 一般这种题目有两种方法：递归和迭代 （递归和迭代有什么区别呢？这个问题还不太懂，希望之后能理解） 第一种：递归方法 思路： 要知道“前序遍历”是如何遍历的——根、左、右 根据这种遍历的方法，定义递归函数： （1）把跳出递归函数的条件放在最前面——if not node: return； （2）根据前序遍历的定义： a.给result先插入根节点的值——result.append(node.val)； b.再去处理左子树——helper(node.left)
数据结构-二叉树（前中后层序遍历-代码实现）
华数云图小分队的博客
04-06 415
二叉树的遍历方式包括前序遍历、中序遍历、后序遍历和层序遍历，这四种遍历方式分别从不同角度对二叉树进行遍历，可以用于寻找特定节点、比较树的结构等。前序遍历前序遍历按照根节点-左子树-右子树的顺序遍历二叉树。具体实现时，先输出当前节点的值，然后递归遍历左子树，最后递归遍历右子树。2.中序遍历中序遍历按照左子树-根节点-右子树的顺序遍历二叉树。具体实现时，先递归遍历左子树，然后输出当前节点的值，最后递归遍历右子树。3.后序遍历后序遍历按照左子树-右子树-根节点的顺序遍历二叉树。
数据结构-二叉树四种遍历方法（代码）
有朋自远方来，不亦乐乎。
08-26 3998
例图：以下的几种遍历均以此图为基准。
Java 平衡二叉树之单旋（左旋，右旋）与双旋
m0_38036210的博客
09-03 2448
1.平衡二叉树 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 首先要明确的是，平衡二叉树是一棵二叉排序树（），它的出现是为了解决普通二叉排序树不平衡的问题。如图，在插入结点之前首先要查找插入位置...
根据中序与后序遍历构建二叉树
二叉树有三种主要的遍历方式：前序遍历、中序遍历和后序遍历。本资料重点介绍了如何利用中序遍历和后序遍历的序列来构建原二叉树。 中序遍历的特点是从左到右依次访问左子树、根节点和右子树，而后序遍历则是先遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值