Java二叉树相关全部代码

最新推荐文章于 2023-07-19 12:55:04 发布
最新推荐文章于 2023-07-19 12:55:04 发布
阅读量127 收藏
点赞数
分类专栏： Java 数据结构 文章标签： 二叉树 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44963741/article/details/104978874
版权 
package tree;

import java.util.ArrayDeque;
import java.util.Stack;

class Node{
	String data;
	Node left;
	Node right;
	public Node(String t) {
		this.data = t;
	}
}
//顺序存储二叉树,完全二叉树
class arrayTree{
	Node[] at;
	//bt为完全二叉树
	public arrayTree(BinaryTree bt){
		ArrayDeque<Node> quene = new ArrayDeque<Node>();
		int count = 0;
		Node temp = bt.root;
		quene.add(temp);
		while(!quene.isEmpty()) {
			temp = quene.poll();
			count++;
			if(temp.left != null) {
				quene.add(temp.left);
			}
			if(temp.right != null) {
				quene.add(temp.right);
			}
		}
		at = new Node[count];
		count = 0;
		temp = bt.root;
		quene.add(temp);
		while(!quene.isEmpty()) {
			temp = quene.poll();
			at[count++] = temp;
			if(temp.left != null) {
				quene.add(temp.left);
			}
			if(temp.right != null) {
				quene.add(temp.right);
			}
		}
	}
	
	//层次遍历
	public void levelOrder(){
		for(int i=0; i<at.length; i++) {
			System.out.print(at[i].data + " ");
		}
	}
	
	public void preOrder() {
		this.preOrder(0);
	}
	//前序遍历
	public void preOrder(int n) {
		if(this.at == null || this.at.length == 0) {
			return ;
		}
		System.out.print(at[n].data + " ");
		if((2 * n + 1) < at.length) {
			preOrder(2 * n + 1);
		}
		if((2 * n + 2) < at.length) {
			preOrder(2 * n + 2);
		}
	}
	public void inOrder() {
		this.inOrder(0);
	}
	//中序遍历
	public void inOrder(int n) {
		if(this.at == null || this.at.length == 0) {
			return ;
		}
		if((2 * n + 1) < at.length) {
			inOrder(2 * n + 1);
		}
		System.out.print(at[n].data + " ");
		if((2 * n + 2) < at.length) {
			inOrder(2 * n + 2);
		}
	}
	public void postOrder() {
		this.postOrder(0);
	}
	//后序遍历
	public void postOrder(int n) {
		if(this.at == null || this.at.length == 0) {
			return ;
		}
		if((2 * n + 1) < at.length) {
			inOrder(2 * n + 1);
		}
		
		if((2 * n + 2) < at.length) {
			inOrder(2 * n + 2);
		}
		System.out.print(at[n].data + " ");
	}
}
public class BinaryTree {

	Node root;
	
	//递归前序遍历
	public void preOrderRec(Node temp) {
		if(temp == null) {
			System.out.println("BinaryTree is empty.");
		}else {
			System.out.print(temp.data + " ");
			if(temp.left != null) {
				preOrderRec(temp.left);
			}
			if(temp.right != null) {
				preOrderRec(temp.right);
			}
		}
	}
	
	//非递归前序遍历算法一，压栈的是右子节点，
	public void preOrderNotRec1() {
		Node temp = root;
		Stack<Node> stack = new Stack<Node>();
		stack.push(temp);
		while(!stack.isEmpty()) {
			temp = stack.pop();
			System.out.print( temp.data + " ");
			if(temp.right != null) {
				stack.push(temp.right);
			}
			if(temp.left != null) {
				stack.push(temp.left);
			}
		}
	}
	//非递归前序遍历算法二，压栈的是每个二叉子树的根节点，利用这个根节点来找右子节点
	public void preOrderNotRec2() {
		Node temp = root;
		Stack<Node> stack = new Stack<Node>();
		while(!stack.isEmpty() || temp != null) {
			if(temp != null) {
				System.out.print( temp.data + " ");
				stack.push(temp);
				temp = temp.left;
			}else {
				temp = stack.pop();
				temp = temp.right;
			}
		}
	}
	//递归中序遍历
	public void inOrderRec(Node temp) {
		if(temp == null) {
			System.out.println("BinaryTree is empty.");
		}else {
			if(temp.left != null) {
				inOrderRec(temp.left);
			}
			System.out.print(temp.data + " ");
			if(temp.right != null) {
				inOrderRec(temp.right);
			}
		}
	}
	//非递归中序遍历
	public void inOrderNotRec() {
		Stack<Node> stack = new Stack<Node>();
		Node temp = root;
		while(!stack.isEmpty() || temp != null) {
			if(temp != null) {
				stack.push(temp);
				temp = temp.left;
			}else {
				temp = stack.pop();
				System.out.print(temp.data + " ");
				temp = temp.right;
			}
		}
	}
	//递归后序遍历
	public void postOrderRec(Node temp) {
		if(temp == null) {
			System.out.println("BinaryTree is empty.");
		}else {
			if(temp.left != null) {
				postOrderRec(temp.left);
			}
			if(temp.right != null) {
				postOrderRec(temp.right);
			}
			System.out.print(temp.data + " ");
			}
	}
	//非递归后序遍历算法一
	public void postOrderNotRec1() {
		Stack<Node> s1 = new Stack<Node>();
		Stack<Node> s2 = new Stack<Node>();
		Node temp = root;
		s1.push(temp);
		while(!s1.isEmpty()) {
			temp = s1.pop();
			s2.push(temp);
			if(temp.left != null) {
				s1.push(temp.left);
			}
			if(temp.right != null) {
				s1.push(temp.right);
			}
		}
		while(!s2.isEmpty()) {
			System.out.print(s2.pop().data + " ");
		}
	}
	//非递归后序遍历算法二
	public void postOrderNotRec2() {
		Stack<Node> s1 = new Stack<Node>();
		//用另一个栈记录是从左子树返回还是从右子树返回
		Stack<Boolean> s2 = new Stack<Boolean>();
		Node temp = root;
		boolean flag;
		while(!s1.isEmpty() || temp != null) {
			if(temp != null) {
				s1.push(temp);
				s2.push(false);
				temp = temp.left;
			}else {
				temp = s1.pop();
				flag = s2.pop();
				//false代表从左子树返回，此时需要先到右子树，并将tag改为true
				if(!flag) {
					s1.push(temp);
					s2.push(true);
					temp = temp.right;
				}else {//从右子树返回说明该节点的左右子树的遍历过了，直接输出
					System.out.print(temp.data + " ");
					//此时temp位于子二叉树的根节点，不为空，将其手动置空，否则出现死循环
					temp = null;
				}
				
			}
		}
	}
	
	//层次遍历
	public void levelOrder() {
		ArrayDeque<Node> quene = new ArrayDeque<Node>();
		Node temp = this.root;
		quene.add(temp);
		while(!quene.isEmpty()) {
			temp = quene.poll();
			System.out.print(temp.data + " ");
			if(temp.left != null) {
				quene.add(temp.left);
			}
			if(temp.right != null) {
				quene.add(temp.right);
			}
		}
	}
	
	//前序遍历查找
	public Node preSearch(Node temp, String value) {
		if(temp.data.equals(value)) {
			return temp;
		}
		Node res = null;
		if(temp.left != null) {
			res = preSearch(temp.left, value);
		}
		if(res != null) {
			return res;
		}
		if(temp.right != null) {
			res = preSearch(temp.right, value);
		}
		return res;
	}
	
	//中序遍历查找
	public Node inSearch(Node temp, String value) {
		Node res = null;
		if(temp.left != null) {
			res = inSearch(temp.left, value);
		}
		if(res != null) {
			return res;
		}
		if(temp.data.equals(value)) {
			return temp;
		}
		if(temp.right != null) {
			res = inSearch(temp.right, value);
		}
		return res;
	}
	
	//后序遍历查找
	public Node postSearch(Node temp, String value) {
		Node res = null;
		if(temp.left != null) {
			res = postSearch(temp.left, value);
		}
		if(res != null) {
			return res;
		}
		if(temp.right != null) {
			res = postSearch(temp.right, value);
		}
		if(res != null) {
			return res;
		}
		if(temp.data.equals(value)) {
			return temp;
		}
		return res;
	}
	//层次遍历查找
	public Node levelSearch(String value) {
		ArrayDeque<Node> quene = new ArrayDeque<Node>();
		Node temp = this.root;
		quene.add(temp);
		while(!quene.isEmpty()) {
			temp = quene.poll();
			if(temp.data.equals(value)) {
				return temp;
			}
			if(temp.left != null) {
				quene.add(temp.left);
			}
			if(temp.right != null) {
				quene.add(temp.right);
			}
		}
		return null;
	}
	//二叉树的删除
	//1.如果要删除的是根节点，置空二叉树
	//2.如果是叶子节点直接删除
	//3.如果不是叶子节点删除子树
	public void delNode1(Node temp, String value) {
		if(this.root == null) {
			System.out.println("empty tree.");
			return ;
		}
		if(this.root.data.equals(value)) {
			this.root = null;
		}
		if(temp.left != null && temp.left.data.equals(value)) {
			temp.left = null;
			return ;
		}
		if(temp.right != null && temp.right.data.equals(value)) {
			temp.right = null;
			return ;
		}
		if(temp.left != null) {
			delNode1(temp.left,value);
		}
		if(temp.right != null) {
			delNode1(temp.right, value);
		}
		
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		BinaryTree bt = new BinaryTree();
		Node A = new Node("A");
		Node B = new Node("B");
		Node C = new Node("C");
		Node D = new Node("D");
		Node E = new Node("E");
		Node F = new Node("F");
		Node G = new Node("G");
		Node H = new Node("H");
		Node I = new Node("I");
		ThreadedBinaryTree tbt = new ThreadedBinaryTree();
		bt.root = A;
		A.left = B;
		A.right = C;
		C.left = I;
		B.left = D;
		B.right = E;
		D.left = F;
		D.right = G;
		E.right = H;
		bt.postOrderNotRec1();
	}
}
//前序  A B D E G H C F
//中序 D B G E H A C F
//后序 D G H E B F C A
Chrix9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树java代码
01-22
java作业中的二叉树代码。在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则此二叉树为完全二叉树。具有n个节点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有2k-1个叶子节点，至多有2k-1个节点。
JAVA编写的二叉树源代码（输入输出都有）
03-09
自己编写的，先序遍历输入，三种遍历输出 输入以回车相隔开，*代表空节点
java的数据结构二叉树_java 数据结构二叉树的实现代码
weixin_42511491的博客
02-15 133
1。 二叉树接口public interface BinaryTreeInterface {public T getRootData();public int getHeight();public int getNumberOfRoot();public void clear();public void setTree(T rootData); // 用rootData设置树public void...
Java二叉树代码
计算机技术学习与应用
11-19 713
package com.instances; /**  * @author Dell  * 二叉树代码  */ public class TreeSetData {  private String data;  private TreeSetData leftNode;  private TreeSetData rightNode;  public TreeSetData(Str
Java输出二叉树先序遍历代码
05-20
附件是Java输出二叉树先序遍历代码，先序遍历的顺序是：首先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。 在这个示例中，TreeNode 类定义了二叉树的节点，每个节点包含一个整数值 val 和...
java 二叉树详解 + 实现代码
12-21
在Java中，我们可以用类来表示二叉树的节点，通常包含数据域（存储节点的数据）以及指向左右子节点的引用。在给定的代码中，`BinTree` 类就是用来表示二叉树节点的，它包含了`leftNode`、`rightNode` 和 `data` 属性...
Java二叉树路径和代码示例
08-28
Java二叉树路径和代码示例 Java二叉树路径和代码示例是 Java 编程中的一种常见问题，该问题主要涉及到二叉树的遍历和路径搜索。给定一个二叉树，找出所有路径中各节点相加总和等于给定目标值的路径。 二叉树是一种...
Java输出中序遍历二叉树代码
最新发布
05-20
附件是Java输出中序遍历二叉树代码，中序遍历的顺序是：首先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 reeNode 类定义了二叉树的节点，BinaryTree 类包含一个 root 属性和 ...
java二叉树实现代码
weixin_34224941的博客
03-11 61
public class Tree { private TreeNode root = null; public Tree() { root = new TreeNode(1, "A"); } private class TreeNode { private int key; ...
Java完全二叉树的创建与四种遍历方法分析
08-28
主要介绍了Java完全二叉树的创建与四种遍历方法,结合实例形式分析了完全二叉树的概念、定义及遍历操作相关实现技巧,并对比分析了满二叉树与完全二叉树的区别,需要的朋友可以参考下
二叉树（java）代码实现
T_ravelers的博客
05-13 533
输入 一组数据   8 3 10 1 6 14 4 7 3  通过 模拟 二叉树 实现数据的 输入  并通过 二叉树 的 中序遍历输出存储的数据  //模拟二叉树并按照中序遍历输出 public class Binarytree { Node root; public void addNode(int data){ if(root == null){ root = new
Java--二叉树代码实现
weixin_73000974的博客
07-19 1714
ps:这里只讲解二叉树的主要方法的实现过程，内容比较进阶，不讲解二叉树的基本知识！！！！
Java遍历二叉树代码
neo19860208的专栏
03-13 97
  public class Node { public Node(String value) { this.value = value; } public Node leftNode;//左节点 public Node rightNode;//右节点 public String value;//当前的节点值 public static void re...
用java代码实现一个简单的二叉树
Sol12363的博客
09-26 174
package com.mccrea.structure.tree; /** * @author mccrea * @version 1.0 * @description: 二叉树的demo * @date 2020/9/26 15:56 */ public class BinaryTreeDemo { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(); .
java二叉树代码_建立一个二叉树，附带查询代码，JAVA代码
weixin_39653733的博客
02-12 138
展开全部import java.util.ArrayList;// 树的一个节点class TreeNode {Object _value = null; // 他的值TreeNode _parent = null; // 他的父节点，根节点没有PARENTArrayList _childList = new ArrayList(); // 他的孩e68a8462616964757a6869646...
Java 二叉树完整代码（递归&迭代）
爱干饭的猿的博客
02-22 2293
Java 二叉树完整代码（递归&迭代）
java二叉树代码实现_java二叉树实现代码
weixin_39595008的博客
02-13 91
public classTree {private TreeNode root = null;publicTree() {root= new TreeNode(1, "A");}private classTreeNode {private intkey;privateString data;private booleanisVisted;privateTreeNode leftChild;priv...
java-二叉树源码
wt_Anytao的博客
10-04 539
package cn.ml.comparable; //二叉树 class BinaryTree>{ private class Node{ //只要是进行数据结构的开发，必然要存在有node类对象 private T data; //保存的数据类型由外部来统一设置 private Node left; private Node right; public Node(T data
java二叉树的便利代码
09-03
以下是Java中二叉树的遍历代码： - 前序遍历（Preorder Traversal）：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。 ```java public void preorderTraversal(TreeNode root) { if (root == null) { return; } System.out.print(root.val + " "); preorderTraversal(root.left); preorderTraversal(root.right); } ``` - 中序遍历（Inorder Traversal）：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。 ```java public void inorderTraversal(TreeNode root) { if (root == null) { return; } inorderTraversal(root.left); System.out.print(root.val + " "); inorderTraversal(root.right); } ``` - 后序遍历（Postorder Traversal）：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。 ```java public void postorderTraversal(TreeNode root) { if (root == null) { return; } postorderTraversal(root.left); postorderTraversal(root.right); System.out.print(root.val + " "); } ``` - 层序遍历（Level Order Traversal）：按照树的层级逐层访问节点。 ```java public void levelOrderTraversal(TreeNode root) { if (root == null) { return; } Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { TreeNode node = queue.poll(); System.out.print(node.val + " "); if (node.left != null) { queue.offer(node.left); } if (node.right != null) { queue.offer(node.right); } } } ``` 以上是一些常见的二叉树遍历方法，根据需要选择合适的遍历方式进行使用。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [java 二叉树详解 + 实现代码](https://download.csdn.net/download/weixin_38685521/13742233)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [用Java实现二叉树的遍历](https://blog.csdn.net/m0_61630116/article/details/124877205)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值