二叉树 前序中序后序遍历与查找与删除节点

最新推荐文章于 2021-06-04 10:40:34 发布
最新推荐文章于 2021-06-04 10:40:34 发布
阅读量418 收藏 2
点赞数
分类专栏： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Azadoo/article/details/106028531
版权 
	//前序遍历
//1先输出当前节点(初始的时候是root节点)
//2如果左子节点不为空，则递归继续前序遍历
//2如果右子节点不为空，则递归继续前序遍历

	//中序遍历
//1如果当前节点的左子节点不为空，则递归中序遍历，
//2输出当前节点 如果当前节点的右子节点不为空，则递归中序遍历

	//后序遍历
//1如果当前节点的左子节点不为空，则递归后序遍历，
//2如果当前节点的右子节点不为空，则递归后序遍历
//3输出当前节点

public class BinaryTreeDemo {
	public static void main(String[] args) {
		
		//创建二叉树
		BinaryTree binaryTree = new BinaryTree();
		HeroNode root = new HeroNode(1,"菲兹");
		HeroNode n2 = new HeroNode(2,"维恩");
		HeroNode n3 = new HeroNode(3,"奎因");
		HeroNode n4 = new HeroNode(4,"潘森");
		
		root.setLeft(n2);
		root.setRight(n3);
		n3.setRight(n4);
		binaryTree.setRoot(root);
		System.out.println("前序遍历");//1234
		binaryTree.preOrder();
		System.out.println("中序遍历");//2134
		binaryTree.infixOrder();
		System.out.println("后序遍历");//2341
		binaryTree.postOrder();
	}
}
//定义BinaryTreeDemo二叉树
class BinaryTree{
	private HeroNode root;
	public HeroNode getRoot() {
		return root;
	}
	public void setRoot(HeroNode 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("二叉树为空 无法遍历");
		}
	}
}
//创建HeroNode节点
class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	/**
	 * @return the no
	 */
	public int getNo() {
		return no;
	}
	public HeroNode(int no, String name) {
		super();
		this.no = no;
		this.name = name;
	}
	/**
	 * @param no the no to set
	 */
	public void setNo(int no) {
		this.no = no;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the left
	 */
	public HeroNode getLeft() {
		return left;
	}
	/**
	 * @param left the left to set
	 */
	public void setLeft(HeroNode left) {
		this.left = left;
	}
	/**
	 * @return the right
	 */
	public HeroNode getRight() {
		return right;
	}
	/**
	 * @param right the right to set
	 */
	public void setRight(HeroNode right) {
		this.right = right;
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + "]";
	}
	//前序遍历
	//1先输出当前节点(初始的时候是root节点)
	//2如果左子节点不为空，则递归继续前序遍历
	//2如果右子节点不为空，则递归继续前序遍历

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

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

	public void postOrder() {
		//向左递归遍历
		if (this.left != null) {
			this.left.preOrder();
		}
		if (this.right != null) {
			this.right.preOrder();
		}
		// 输出父节点
		System.out.println(this);
	}
}

二叉树查找指定节点

要求
1)请编写前序查找，中序查找和后序查找的方法。
2)并分别使用三种查找方式，查找heroNO =5的节点
3)并分析各种查找方式，分别比较了多少次
使用前序，中序，后序的方式来查询指定的结点
前序查找思路
1.先判断当前结点的no是否等于要查找的
2.如果是相等，则返回当前结点
3.如果不等，则判断当前结点的左子节点是否为空,如果不为空，则递归前
序查找.
4.如果左递归前序查找，找到结点，则返回，否继续判断，当前的结点的右
子节点是否为空，如果不空，则继续向右递归前序查找.
中序查找思路
1.判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
2.如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当中前结点，否则继续进行右递归的中序查找
3.如果右递归中序查找，找到就返回，否则返回null
后序查找思路
1.判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
2.如果找到，就返回，如果没有找到，就判断当前结点的右子节点是否为空，如果不为空，则右递归进行后序查找，如果找到，就返回
3.就和当前结点进行，比如，如果是则返回，否则返回null


public class BinaryTreeDemo {
	public static void main(String[] args) {
		
		//创建二叉树
		BinaryTree binaryTree = new BinaryTree();
		HeroNode root = new HeroNode(1,"菲兹");
		HeroNode n2 = new HeroNode(2,"维恩");
		HeroNode n3 = new HeroNode(3,"奎因");
		HeroNode n4 = new HeroNode(4,"潘森");
		
		root.setLeft(n2);
		root.setRight(n3);
		n3.setRight(n4);
		binaryTree.setRoot(root);
//		System.out.println("前序遍历");//1234
//		binaryTree.preOrder();
//		System.out.println("中序遍历");//2134
//		binaryTree.infixOrder();
//		System.out.println("后序遍历");//2341
//		binaryTree.postOrder();
		//前序遍历
		System.out.println("前序遍历");
		HeroNode resNode = binaryTree.preOrderSearch(4);
		if(resNode != null) {
			System.out.println(resNode.getName()+" "+resNode.getNo());
			
		}else {
			System.out.println("未找到");
		}
	}
}
//定义BinaryTreeDemo二叉树
class BinaryTree{
	private HeroNode root;
	public HeroNode getRoot() {
		return root;
	}
	public void setRoot(HeroNode 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 HeroNode preOrderSearch(int no) {
		if(this.root != null) {
			return this.root.preOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
		
	}
	//中序遍历
	public HeroNode infixOrderSearch(int no) {
		if(this.root != null) {
			return this.root.infixOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
	}
	//后序遍历
	public HeroNode postOrderSearch(int no) {
		if(this.root != null) {
			return this.root.postOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
	}
	
}
//创建HeroNode节点
class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	/**
	 * @return the no
	 */
	public int getNo() {
		return no;
	}
	public HeroNode(int no, String name) {
		super();
		this.no = no;
		this.name = name;
	}
	/**
	 * @param no the no to set
	 */
	public void setNo(int no) {
		this.no = no;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the left
	 */
	public HeroNode getLeft() {
		return left;
	}
	/**
	 * @param left the left to set
	 */
	public void setLeft(HeroNode left) {
		this.left = left;
	}
	/**
	 * @return the right
	 */
	public HeroNode getRight() {
		return right;
	}
	/**
	 * @param right the right to set
	 */
	public void setRight(HeroNode right) {
		this.right = right;
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + "]";
	}
	//前序遍历
	//1先输出当前节点(初始的时候是root节点)
	//2如果左子节点不为空，则递归继续前序遍历
	//2如果右子节点不为空，则递归继续前序遍历

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

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

	public void postOrder() {
		//向左递归遍历
		if (this.left != null) {
			this.left.preOrder();
		}
		if (this.right != null) {
			this.right.preOrder();
		}
		// 输出父节点
		System.out.println(this);
	}
	//前序查询
	public HeroNode preOrderSearch(int no) {
		System.out.println("进入前序遍历 比较次数");
		if(this.no == no) {
			return this;
		}else {
			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;
		}
		// 左边没找到则找中间
		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(this.no == no) {
			return this;
		}
		return resNode;

	}
	
}

删除

要求
1.如果删除的节点是叶子节点，则删除该节点
2.如果删除的节点是非叶子节点，则删除该子树
思路
1.因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点。
2.如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将this.left = null;并且就返回(结束递归删除)
3.如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right= null ;并 且就返回(结束递归删除)
4.如果第2和第3步没有删除结点,那么我们就需要向左子树进行递归删除
5.如果第4步也没有删除结点，则应当向右子树进行递归删除。


public class BinaryTreeDemo {
	public static void main(String[] args) {
		
		//创建二叉树
		BinaryTree binaryTree = new BinaryTree();
		HeroNode root = new HeroNode(1,"菲兹");
		HeroNode n2 = new HeroNode(2,"维恩");
		HeroNode n3 = new HeroNode(3,"奎因");
		HeroNode n4 = new HeroNode(4,"潘森");
		
		root.setLeft(n2);
		root.setRight(n3);
		n3.setRight(n4);
		binaryTree.setRoot(root);
//		System.out.println("前序遍历");//1234
//		binaryTree.preOrder();
//		System.out.println("中序遍历");//2134
//		binaryTree.infixOrder();
//		System.out.println("后序遍历");//2341
//		binaryTree.postOrder();
		
		//前序遍历
//		System.out.println("前序遍历");
//		HeroNode resNode = binaryTree.preOrderSearch(4);
//		if(resNode != null) {
//			System.out.println(resNode.getName()+" "+resNode.getNo());
//			
//		}else {
//			System.out.println("未找到");
//		}
		
		//测试删除
		System.out.println("删除前 前序遍历");
		binaryTree.preOrder();
		binaryTree.delNode(3);
		System.out.println("删除后 前序遍历");
		binaryTree.postOrder();
	}
}
//定义BinaryTreeDemo二叉树
class BinaryTree{
	private HeroNode root;
	public HeroNode getRoot() {
		return root;
	}
	public void setRoot(HeroNode 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 HeroNode preOrderSearch(int no) {
		if(this.root != null) {
			return this.root.preOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
		
	}
	//中序遍历
	public HeroNode infixOrderSearch(int no) {
		if(this.root != null) {
			return this.root.infixOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
	}
	//后序遍历
	public HeroNode postOrderSearch(int no) {
		if(this.root != null) {
			return this.root.postOrderSearch(no);
		}else {
			System.out.println("二叉树为空 无法遍历");
			return null;
		}
	}
	//删除节点
	public void delNode(int no) {
		if(root != null) {
			//如果只有一个root节点 立即判断是否为要删除节点
			if(root.getNo() == no) {
				root = null;
			}else {
				root.delNode(no);
			}
		}
	}
	
}
//创建HeroNode节点
class HeroNode{
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;
	/**
	 * @return the no
	 */
	public int getNo() {
		return no;
	}
	public HeroNode(int no, String name) {
		super();
		this.no = no;
		this.name = name;
	}
	/**
	 * @param no the no to set
	 */
	public void setNo(int no) {
		this.no = no;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the left
	 */
	public HeroNode getLeft() {
		return left;
	}
	/**
	 * @param left the left to set
	 */
	public void setLeft(HeroNode left) {
		this.left = left;
	}
	/**
	 * @return the right
	 */
	public HeroNode getRight() {
		return right;
	}
	/**
	 * @param right the right to set
	 */
	public void setRight(HeroNode right) {
		this.right = right;
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + "]";
	}
	//前序遍历
	//1先输出当前节点(初始的时候是root节点)
	//2如果左子节点不为空，则递归继续前序遍历
	//2如果右子节点不为空，则递归继续前序遍历

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

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

	public void postOrder() {
		//向左递归遍历
		if (this.left != null) {
			this.left.preOrder();
		}
		if (this.right != null) {
			this.right.preOrder();
		}
		// 输出父节点
		System.out.println(this);
	}
	//前序查询
	public HeroNode preOrderSearch(int no) {
		System.out.println("进入前序遍历 比较次数");
		if(this.no == no) {
			return this;
		}else {
			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;
		}
		// 左边没找到则找中间
		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(this.no == no) {
			return this;
		}
		return resNode;

	}
	public void delNode(int no) {
		
		//递归删除结点
		//1.如果删除的节点是叶子节点，则删除该节点
		//2.如果删除的节点是非叶子节点，则删除该子树
//		1.因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点。
//		2.如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将this.left = null;并且就返回(结束递归删除)
//		3.如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right= null ;并 且就返回(结束递归删除)
//		4.如果第2和第3步没有删除结点,那么我们就需要向左子树进行递归删除
//		5.如果第4步也没有删除结点，则应当向右子树进行递归删除。

		 //2.如果当前结点的左子结点不为空,并且左子结点就是要删除结点，就将this.left = null;并且就返回(结束递归删除)
		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);
			
		}
		 
	}
	
}
Azadoo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言数据结构学习笔记(11)-二叉排序树的创建遍历及删除
laven_li的博客
10-29 511
/* 二叉排序树的创建遍历及删除 输出结果： 中序遍历:1 2 4 5 6 7 9 10 14 15 17 18 19 20 25 30 35 40 层序遍历:20 14 25 5 15 35 4 10 17 30 40 2 6 19 1 9 18 7 Treeheight = 7 请输入待寻找的数字:5 找到了5. 请输入待寻找父节点的数字:5 5的父节点值为14 请输入要删除的节点值:5 删除后root = 2...
机试题 二叉排序树
毛毛的博客
07-09 668
题目描述 输入一系列整数，建立二叉排序树，并进行前序，中序，后序遍历。 输入描述: 输入第一行包括一个整数n(1<=n<=100)。 接下来的一行包括n个整数。 输出描述: 可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。 每种遍历结果输出一行。每行最后一个数据之后有一个空格。 输入中可能有重复元素，但是输出的...
数据结构系列，二叉排序树的结点删除、重排
lin20080410的专栏
01-11 2099
二叉排序树 又称二叉查找树，它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值。 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值。 它的左右子树，也分别为二叉排序树。 构造一棵二叉排序树的目的，不是为了排序，而是为了提高查找、插入删除关键字的速度。 二叉树的删除，需要保证一点，不能因为删除了结点，而让这棵树变得不满...
二叉排序树删除节点_python笔试面试项目实战2020百练4实现二叉排序树及其中序遍历...
weixin_39643336的博客
11-24 86
树结构是一种非常重要的非线性结构,该结构中一个数据元素可以有两个或两个以上的直接后继元素,树可以用来描述客观世界中广泛存在的层次结构关系。树与二叉树的定义1.树的定义树是n(n≥0)个节点的有限集合,当n=0时称为空树。在任一非空树(n>0)中,有且仅有一个称为根的节点;其余节点可分为m(m≥0)个互不相交的有限集T 1 ,T 2 ,...,T m ,其中每个T i 又都是一棵树,并且称为根...
二叉排序树
tangyaya8的博客
10-04 105
树 记得在软件工程的课程中，老师讲过：程序=数据结构+算法。随着学习的深入，越来越能理解这句话的含义了，吧一段程序或者一个应用抽象来看，一层一层剥去，最后剩下来的无非是用来存储内存数据的数据结构和怎么怎么存储以及实现业务逻辑的算法。在计算机的世界里，存储的数据的数据结构有很多，它们被用到不同的场景来解决不同的问题，只有了解了各种数据结构的实现和用途，我们才能将其用到正确的场景，解决合适的问题，所以...
二叉树的遍历，前序遍历 中序遍历 后序遍历
最新发布
11-11
总结来说，二叉树的前序、中序和后序遍历是数据结构与算法领域中的核心概念，它们对于理解和操作二叉树至关重要。掌握这三种遍历方法不仅有助于提升编程技能，还能在解决问题时提供灵活的思路。无论是进行数据处理、...
erchashu.rar_前序 中序 后序
09-23
这次我们要探讨的是二叉树的三种主要遍历方式：前序遍历、中序遍历和后序遍历。这些遍历方法在解决问题、数据存储和检索以及编译器设计等方面都有广泛应用。 标题“erchashu.rar_前序 中序 后序”暗示我们将关注...
已知二叉树的前序和中序遍历，打印后序遍历
03-26
前序、中序和后序遍历是二叉树三种基本的遍历方式，每种方式都有其特定的访问顺序。这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -...
LastOrderTree.rar_LastOrderTree_前序 中序 后序
09-24
可能包括了二叉树节点的定义、插入新节点、以及前序、中序、后序遍历的函数。理解这些代码可以帮助我们掌握二叉树的动态构建和遍历技巧。 通过这个项目，我们可以学习到如何在实际编程中运用二叉树数据结构，以及...
根据二叉树前序遍历和中序遍历的结果输出后序遍历(java)
04-11
本话题将详细探讨如何根据给定的二叉树前序遍历和中序遍历的结果，利用Java来输出其后序遍历的序列。 前序遍历的顺序是：根节点 -> 左子树 -> 右子树； 中序遍历的顺序是：左子树 -> 根节点 -> 右子树； 后序遍历的...
C语言实现二叉树的创建、插入、删除、遍历等操作
05-28
二叉树的先序、中序、后续、计算叶子节点和树的深度的源代码，计算度为0,1,2的节点个数。 包括排序二叉树的实现
树结构练习——排序二叉树的中序遍历
baiqiaoxiang的博客
05-19 260
树结构练习——排序二叉树的中序遍历 Description 在树结构中，有一种特殊的二叉树叫做排序二叉树，直观的理解就是——(1).每个节点中包含有一个关键值 (2).任意一个节点的左子树（如果存在的话）的关键值小于该节点的关键值 (3).任意一个节点的右子树（如果存在的话）的关键值大于该节点的关键值。现给定一组数据，请你对这组数据按给定顺序建立一棵排序二叉树，并输出其中序遍历的结果。 Input 输入包含多组数据，每组数据格式如下。 第一行包含一个整数n，为关键值的个数，关键值用整数表示。(n<=1
关于任意两种遍历序列相同所确定的二叉树
酒中欢的博客
11-09 6999
二叉树的先序遍历：根——左子树——右子树 二叉树的中序遍历：左子树——根——右子树 二叉树的后序遍历：左子树——右子树——根 二叉树的层次遍历：从第一层开始，从上至下逐层遍历，在同一层中，则按照从左到右的顺序对节点逐个访问。 （1）先序序列与后序序列相同 空树或为只有根结点的二叉树 （2）中序序列与后序序列相同 空树或为任一结点至多只有左子结点的二叉树 （3）先序序列与中序序列相同 空树或为任一结...
二叉树的前序、中序、后序遍历 查找 删除
sphone89的专栏
10-16 1176
<br />(二叉树的删除)在本练习中，我们讨论从二叉查找树删除节点问题。删除算法不像插入算法那么简单明了。删除一个值可能有三种不同的情况————该值包含在一个叶子节点中（没有子节点），该值包含在只有一个子节点中或者包含在两个子节点的节点中。<br />如果该项在叶节点中，直接删除该节点，将其父节点指向它的指针置为空。<br />如果该项包含在只含一个子节点的节点中，把父节点的指针指向它的子节点再删除这个数据项，就是由它的子节点替代该节点的位置。最后一种情况是最难的。当要删除的节点含有2个子节点时，由另一个
二叉树前序中序后序遍历、节点的查找及其子树的删除
one111a的博客
04-07 247
代码展示 package demo5; public class BinaryTree { TreeNode root; //设置根节点 public void setRoot(TreeNode root){ this.root = root; } //获取根节点 public TreeNode getRoot(){ ...
树的遍历-给定一棵二叉树的后序遍历和中序遍历，输出其层序遍历的序列
Luo_LA的博客
06-04 1万+
给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。 输入样例： 7 2 3 1 5 7 6 4 1 2 3 4 5 6 7 输出样例： 4 1 6 3 5 7 2 解题思路： 已知后序序列和中序序列确定树的结构： 先建立一个树根节点，后续序列的最后一个即为树根节点。确定树根后，遍历中序序列找到树根节点，树根节点的左边的序列即为树根左孩子的中序序列，右边为右孩子的中序序列。计算左孩子的节点个数n，右孩子节点个数m，遍历后序序列的前n个是左孩子的后续序列，再后面
二叉树遍历（前序、中序、后序、层次遍历、深度优先、广度优先）
热门推荐
My_Jobs的专栏
02-03 37万+
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的
二叉树，返回它的中序 遍历。
静看岁月
12-07 1122
给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 递归法：其实就是三行代码 inorderTraversal(root-&gt;left); .push_back(root-&gt;val); inorderTraversal(roo...
Java：二叉搜索树-BinarySearchTree-前序遍历-中序遍历-后序遍历-层序遍历-删除节点
_
06-11 474
二叉查找树（Binary Search Tree） 一、定义 它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。 如图： 二、添加 先找到需要添加的位置，然后ad
c++ 二叉树 前序中序后序遍历二叉树 计算树的深度 计算叶子结点个数 查找双亲 查找兄弟 代码
06-01
后序遍历： ```c++ void postOrder(TreeNode* root) { if (root == nullptr) return; postOrder(root->left); postOrder(root->right); cout << root->val ; } ``` 计算树的深度： ```c++ int depth(TreeNode...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值