二叉树的java实现(1)

最新推荐文章于 2024-05-10 15:15:56 发布
最新推荐文章于 2024-05-10 15:15:56 发布
阅读量365 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41172784/article/details/107251081
版权

二叉树

二叉树

什么是二叉树

二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分，说白了就是二叉树最多有两个子节点。
我们来举个例子
在这里插入图片描述
我们通过上述的图片可以得知没有子节点个数大于两个的，所以是二叉树。
我们举个反例
在这里插入图片描述

完全二叉树

一个二叉树的节点按照从上往下，从左至右的顺序，那么这个二叉树叫做完全二叉树
举个例子
在这里插入图片描述
举个反例
在这里插入图片描述
因为二叉树要按照从上到下的顺序，从左至右的顺序进行排列，目前我们从上往下是满足的，但是从左至右不满足，因为缺少两个节点，如下所示
在这里插入图片描述

满二叉树

二叉树的所有叶子节点都在最后一层，而且节点个数满足2^n-1，n就是树的高度
举个例子
对上述图，作以下修改
在这里插入图片描述
树的叶子节点都在最后一层，一共有7个结点 2^3-1 = 7，所以满足满二叉树

树的几个概念

树的各个节点
在这里插入图片描述
节点的权
节点1存储的值是1，那么节点1所存储的数值大小就叫做节点1的权
节点的度
一个节点有多少个子节点，节点的度就是多少
叶子节点
节点的度为0的节点，就叫做叶子节点
树的高度
树有几层，数的高度就是几，上述树的高度为3

开发准备

新建工程

工程大体结构如下
在这里插入图片描述

初始化工程

// BinaryTree
public class BinaryTree {
	private Node rootNode;//根节点
	
	public Node getRootNode() {
		return rootNode;
	}

	public void setRootNode(Node rootNode) {
		this.rootNode = rootNode;
	}
	
	@Override
	public String toString() {
		return "BinaryTree [rootNode=" + rootNode + "]";
	}
	public BinaryTree() {
		
	}
	
	public static class Node{
		private int value;//节点的权
		private Node leftNode;//左子节点
		private Node rightNode;//右子节点
		public int getValue() {
			return value;
		}
		public void setValue(int value) {
			this.value = value;
		}
		public Node getLeftNode() {
			return leftNode;
		}
		public void setLeftNode(Node leftNode) {
			this.leftNode = leftNode;
		}
		public Node getRightNode() {
			return rightNode;
		}
		public void setRightNode(Node rightNode) {
			this.rightNode = rightNode;
		}
		public Node(int value) {
			this.value = value;
		}
		@Override
		public String toString() {
			return "Node [value=" + value + "]";
		}
	}
}

添加节点

普通二叉树添加节点

我们首先按照普通的二叉树来，对于普通的二叉树，我们想要添加节点，我们只需要找到父节点，直接对父节点进行操作即可
画图来解释一下
在这里插入图片描述

@Test
	void testAddNode() {
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		tree.setRootNode(rootNode);
		System.out.println("树的根节点为" + tree.getRootNode());
		//找到父节点
		Node parentNode = tree.getRootNode();
		//给父节点添加
		parentNode.setLeftNode(new BinaryTree.Node(2));
		parentNode.setRightNode(new BinaryTree.Node(3));
		System.out.println("根节点的左子节点为" + parentNode.getLeftNode());
		System.out.println("根节点的右子节点为" + parentNode.getRightNode());
	}

结果
在这里插入图片描述

完全二叉树添加节点

我们知道完全二叉树是按照从上到下，从左到右的规则排列节点的，那么我们添加addNode()的方法

public void addNode(Node node)
	{
		if(this.rootNode == null) 
		{
			this.rootNode = node;
			return;
		}
		//找到父节点
		LinkedList<Node> list = new LinkedList<>();
		list.offer(this.rootNode);
		while(list.isEmpty())
		{
			Node currNode = list.poll();
			if(currNode.getLeftNode() !=null) list.offer(currNode.getLeftNode());
			if(currNode.getRightNode() !=null) list.offer(currNode.getRightNode());
			if(currNode.getLeftNode() == null) 
			{
				currNode.setLeftNode(node);
				return;
			}
			if(currNode.getRightNode() == null) 
			{
				currNode.setRightNode(node);
				return;
			}
		}
		
	}

测试

@Test
	void testAddNode1(){
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		Node leftNode = new BinaryTree.Node(2);
		Node rightNode = new BinaryTree.Node(3);
		Node node4 = new BinaryTree.Node(4);
		tree.addNode(rootNode);
		tree.addNode(leftNode);
		tree.addNode(rightNode);
		tree.addNode(node4);
		System.out.println("根节点：" + tree.getRootNode());
		System.out.println("根节点的左子节点：" + tree.getRootNode().getLeftNode());
		System.out.println("根节点的右子节点：" + tree.getRootNode().getRightNode());
		System.out.println("根节点的左子节点的左子节点：" + tree.getRootNode().getLeftNode().getLeftNode());
		System.out.println("根节点的左子节点的右子节点：" + tree.getRootNode().getLeftNode().getRightNode());
		System.out.println("根节点的右子节点的左子节点：" + tree.getRootNode().getRightNode().getLeftNode());
		System.out.println("根节点的右子节点的右子节点：" + tree.getRootNode().getRightNode().getRightNode());
	}

结果
在这里插入图片描述

遍历

在这里插入图片描述

前序遍历

//BinaryTree
public String frontQueryAll() {
		if(this.rootNode == null) return "{}";
		StringBuilder sBuilder = new StringBuilder(20);
		sBuilder.append("{");
		this.rootNode.frontHelp(sBuilder);
		sBuilder.deleteCharAt(1);
		sBuilder.append("}");
		return sBuilder.toString();
	}
//Node
public void frontHelp(StringBuilder sBuilder) {
			if(this != null)
			{
				sBuilder.append(',');
				sBuilder.append(this.getValue());
			}
			if(this.getLeftNode() != null) this.getLeftNode().frontHelp(sBuilder);
			if(this.getRightNode() != null) this.getRightNode().frontHelp(sBuilder);
		}

测试

@Test
	void testFront() {
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		Node leftNode = new BinaryTree.Node(2);
		Node rightNode = new BinaryTree.Node(3);
		Node node4 = new BinaryTree.Node(4);
		Node node5 = new BinaryTree.Node(5);
		Node node6 = new BinaryTree.Node(6);
		Node node7 = new BinaryTree.Node(7);
		tree.addNode(rootNode);
		tree.addNode(leftNode);
		tree.addNode(rightNode);
		tree.addNode(node4);
		tree.addNode(node5);
		tree.addNode(node6);
		tree.addNode(node7);
		System.out.println(tree.frontQueryAll());
	}

结果
在这里插入图片描述

层次遍历

//BinaryTree
public String queryAll() {
		if(this.rootNode == null) return "{}";
		StringBuilder sBuilder = new StringBuilder(20);
		sBuilder.append("{");
		query(sBuilder);
		sBuilder.deleteCharAt(1);
		sBuilder.append("}");
		return sBuilder.toString();
	}
//BinaryTree
	private void query(StringBuilder sBuilder) {
		LinkedList<Node> list = new LinkedList<>();
		list.offer(this.rootNode);
		while(!list.isEmpty())
		{
			Node currNode = list.poll();
			sBuilder.append(',');
			sBuilder.append(currNode.getValue());
			if(currNode.getLeftNode() !=null) list.offer(currNode.getLeftNode());
			if(currNode.getRightNode() !=null) list.offer(currNode.getRightNode());
		}
	}

测试

@Test
	void testquerytAll() {
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		Node leftNode = new BinaryTree.Node(2);
		Node rightNode = new BinaryTree.Node(3);
		Node node4 = new BinaryTree.Node(4);
		Node node5 = new BinaryTree.Node(5);
		Node node6 = new BinaryTree.Node(6);
		Node node7 = new BinaryTree.Node(7);
		tree.addNode(rootNode);
		tree.addNode(leftNode);
		tree.addNode(rightNode);
		tree.addNode(node4);
		tree.addNode(node5);
		tree.addNode(node6);
		tree.addNode(node7);
		System.out.println(tree.queryAll());
	}

结果
在这里插入图片描述

中序遍历

//BinaryTree
public String centerQueryAll() {
		if(this.rootNode == null) return "{}";
		StringBuilder sBuilder = new StringBuilder(20);
		sBuilder.append("{");
		this.rootNode.centerHelp(sBuilder);
		sBuilder.deleteCharAt(1);
		sBuilder.append("}");
		return sBuilder.toString();
}
//Node
public void centerHelp(StringBuilder sBuilder) {
			if(this.getLeftNode() != null) this.getLeftNode().centerHelp(sBuilder);
			if(this != null)
			{
				sBuilder.append(',');
				sBuilder.append(this.getValue());
			}
			if(this.getRightNode() != null) this.getRightNode().centerHelp(sBuilder);
		}

测试

@Test
	void testCenter() {
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		Node leftNode = new BinaryTree.Node(2);
		Node rightNode = new BinaryTree.Node(3);
		Node node4 = new BinaryTree.Node(4);
		Node node5 = new BinaryTree.Node(5);
		Node node6 = new BinaryTree.Node(6);
		Node node7 = new BinaryTree.Node(7);
		tree.addNode(rootNode);
		tree.addNode(leftNode);
		tree.addNode(rightNode);
		tree.addNode(node4);
		tree.addNode(node5);
		tree.addNode(node6);
		tree.addNode(node7);
		System.out.println(tree.centerQueryAll());
	}

结果
在这里插入图片描述

后序遍历

//BinaryTree
public String lastQueryAll() {
		if(this.rootNode == null) return "{}";
		StringBuilder sBuilder = new StringBuilder(20);
		sBuilder.append("{");
		this.rootNode.lastHelp(sBuilder);
		sBuilder.deleteCharAt(1);
		sBuilder.append("}");
		return sBuilder.toString();
}
//Node
public void lastHelp(StringBuilder sBuilder) {
			if(this.getLeftNode() != null) this.getLeftNode().lastHelp(sBuilder);
			if(this.getRightNode() != null) this.getRightNode().lastHelp(sBuilder);
			if(this != null)
			{
				sBuilder.append(',');
				sBuilder.append(this.getValue());
			}
		}

测试

@Test
	void testLast() {
		BinaryTree tree = new BinaryTree();
		Node rootNode = new BinaryTree.Node(1);
		Node leftNode = new BinaryTree.Node(2);
		Node rightNode = new BinaryTree.Node(3);
		Node node4 = new BinaryTree.Node(4);
		Node node5 = new BinaryTree.Node(5);
		Node node6 = new BinaryTree.Node(6);
		Node node7 = new BinaryTree.Node(7);
		tree.addNode(rootNode);
		tree.addNode(leftNode);
		tree.addNode(rightNode);
		tree.addNode(node4);
		tree.addNode(node5);
		tree.addNode(node6);
		tree.addNode(node7);
		System.out.println(tree.lastQueryAll());
	}

结果
在这里插入图片描述

浑身带着仙气
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树1 树的同构（Java）
NinoSun的博客
09-04 286
题目 给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。 现给定两棵树，请你判断它们是否是同构的。 输入格式: 输入给出2棵二叉树树的信息。对于每棵树，首先在一行中给出一个非负整数N (≤10)，即该树的结点数（此时假设结点从...
二叉树的遍历（java）
Healist的博客
01-20 312
二叉树的遍历分为中序，前序，后序；就是利用函数递归来实现的遍历，没啥好说的，直接上代码：class TreeNode { int value; TreeNode left_node; TreeNode right_node; public TreeNode(int value) { this.value = value; this.le
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
【Java】二叉树
qq_61635026的博客
07-08 2230
二叉树（Binary Tree）是一种常见的树形结构，它由节点（Node）和节点之间的关系构成。每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树中的每个节点可以为空（null）。
java版数据结构：二叉树
最新发布
2303_80025768的博客
05-10 763
二叉树的基本应用
数据结构（二叉树）——Java实现
m0_56911284的博客
11-03 2767
认识二叉树，并用Java实现其一系列的操作。
Java语言----二叉树
tq02的博客
05-28 2886
二叉树详细讲解，以及Java实现代码
Java实现先序遍历二叉树
04-26
在Java中，实现二叉树的先序遍历可以通过递归来完成。先序遍历的顺序是：首先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，包含数据域和指向左右子...
Java实现表达式二叉树
09-01
【Java实现表达式二叉树】是编程领域中一种数据结构的应用，主要用于处理数学表达式。在计算机科学中，二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。表达式二叉树，又...
二叉树java实现
08-27
在Java中实现二叉树，我们可以自定义一个类来表示树节点，并通过节点之间的连接来构建整个树形结构。这篇博客主要讨论了如何在Java中实现二叉树的基本操作，包括递归和非递归方式的三种遍历顺序：前序遍历、中序遍历...
数据结构-二叉树 JAVA语言实现
10-16
总结来说，理解和掌握二叉树以及如何用JAVA实现它们是成为优秀程序员的关键一步。通过实践，你可以更深入地了解数据结构的精髓，提升算法设计能力，并为解决复杂问题打下坚实基础。对于初学者，可以从简单的二叉树...
java 二叉树实现
10-12
java二叉树实现 （简单实现，入门用） /**创建二叉树*/ public BinaryTree createTree(String treeStr); /**寻找结点*/ public BinaryTree findNode(BinaryTree tree ,char sign); /**找所给结点的左子树*/ ...
Java二叉树
m0_64318128的博客
10-16 1720
二叉树的概念、性质、以及二叉树的基本操作
二叉树（Java版）
WYSCODER的博客
08-04 2897
二叉树，看这一篇就够了~~~
Java数据结构————二叉树
爱敲代码的三毛的博客
08-20 1076
文章目录一、树型结构（了解）1.概念2. 树与非树3. 树的一些重要的概念4. 树的表示形式（了解）5. 树的一些应用二、二叉树1.二叉树的概念2.二叉树的基本形态3.两种特殊的二叉树4. 二叉树的性质5. 二叉树的存储三、二叉树的基本操作1.二叉树的遍历2.前序遍历3. 中序遍历4. 后序遍历5. 求结点个数6.求叶子结点个数7. 求第 k 层结点个数8.获取二叉树的高度9. 查找 val 所在结点10. 层序遍历11. 判断一棵树是不是完全二叉树完！ 要想了解二叉树先要知道什么是树 一、树型结构（..
【数据结构】用Java实现一棵二叉树
qq_53869058的博客
03-30 3842
这里给出从前序与中序遍历序列构造二叉树、从中序与后序遍历序列构造二叉树以及二叉树的基本操作。
[JAVA数据结构] 二叉树 - 详解
weixin_55250388的博客
02-01 1189
对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。二叉树的顺序存储，通过学习你会发现，其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象。1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ B）结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推,, 上图为4层。Node right;
平衡二叉树 java 实现
04-13
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。在Java中，可以通过以下步骤实现平衡二叉树： 1. 定义节点类：首先定义一个节点类，包含节点值、左子节点和右子节点等属性。 ```java class Node { int value; Node left; Node right; public Node(int value) { this.value = value; this.left = null; this.right = null; } } ``` 2. 实现平衡二叉树类：创建一个平衡二叉树类，包含插入节点、删除节点、旋转操作等方法。 ```java class AVLTree { private Node root; // 插入节点 public void insert(int value) { root = insertNode(root, value); } private Node insertNode(Node root, int value) { if (root == null) { return new Node(value); } if (value < root.value) { root.left = insertNode(root.left, value); } else if (value > root.value) { root.right = insertNode(root.right, value); } else { // 如果存在相同值的节点，可以根据需求进行处理 return root; } // 更新节点的高度 root.height = 1 + Math.max(getHeight(root.left), getHeight(root.right)); // 平衡操作 int balance = getBalance(root); // 左左情况，进行右旋操作 if (balance > 1 && value < root.left.value) { return rightRotate(root); } // 右右情况，进行左旋操作 if (balance < -1 && value > root.right.value) { return leftRotate(root); } // 左右情况，先左旋再右旋 if (balance > 1 && value > root.left.value) { root.left = leftRotate(root.left); return rightRotate(root); } // 右左情况，先右旋再左旋 if (balance < -1 && value < root.right.value) { root.right = rightRotate(root.right); return leftRotate(root); } return root; } // 删除节点 public void delete(int value) { root = deleteNode(root, value); } private Node deleteNode(Node root, int value) { // 空树或未找到节点 if (root == null) { return root; } if (value < root.value) { root.left = deleteNode(root.left, value); } else if (value > root.value) { root.right = deleteNode(root.right, value); } else { // 找到要删除的节点 // 节点只有一个子节点或无子节点 if (root.left == null || root.right == null) { Node temp = null; if (temp == root.left) { temp = root.right; } else { temp = root.left; } // 无子节点的情况 if (temp == null) { temp = root; root = null; } else { // 一个子节点的情况 root = temp; } } else { // 节点有两个子节点，找到右子树中最小的节点 Node temp = minValueNode(root.right); // 将右子树中最小节点的值赋给要删除的节点 root.value = temp.value; // 删除右子树中最小的节点 root.right = deleteNode(root.right, temp.value); } } // 更新节点的高度 root.height = 1 + Math.max(getHeight(root.left), getHeight(root.right)); // 平衡操作 int balance = getBalance(root); // 左左情况，进行右旋操作 if (balance > 1 && getBalance(root.left) >= 0) { return rightRotate(root); } // 左右情况，先左旋再右旋 if (balance > 1 && getBalance(root.left) < 0) { root.left = leftRotate(root.left); return rightRotate(root); } // 右右情况，进行左旋操作 if (balance < -1 && getBalance(root.right) <= 0) { return leftRotate(root); } // 右左情况，先右旋再左旋 if (balance < -1 && getBalance(root.right) > 0) { root.right = rightRotate(root.right); return leftRotate(root); } return root; } // 获取节点的高度 private int getHeight(Node node) { if (node == null) { return 0; } return node.height; } // 获取节点的平衡因子 private int getBalance(Node node) { if (node == null) { return 0; } return getHeight(node.left) - getHeight(node.right); } // 右旋操作 private Node rightRotate(Node y) { Node x = y.left; Node T2 = x.right; x.right = y; y.left = T2; y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1; x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1; return x; } // 左旋操作 private Node leftRotate(Node x) { Node y = x.right; Node T2 = y.left; y.left = x; x.right = T2; x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1; y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1; return y; } // 获取最小值节点 private Node minValueNode(Node node) { Node current = node; while (current.left != null) { current = current.left; } return current; } } ``` 以上是一个简单的平衡二叉树的Java实现，包括插入节点、删除节点、旋转操作等方法。你可以根据需要进行调整和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值