Day 11

最新推荐文章于 2024-09-05 10:39:00 发布
最新推荐文章于 2024-09-05 10:39:00 发布
阅读量190 收藏
点赞数
文章标签： java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45085885/article/details/124231502
版权

Java 树与二叉树

文章目录


学习来源： 日撸 Java 三百行（21-30天，树与二叉树）

一、二叉树的深度遍历的递归实现

  1. 二叉树的遍历比存储、建立要简单. 所以先“手动”建立一个二叉树来玩.
  2. 递归算法写起来就是舒服. 前、中、后序的代码差别只有输出语句的位置.
  3. 不需要额外的节点类, 每棵二叉树 (树) 都可以从自己的根结点找到其它所有节点. 这个需要自悟.
  4. 获取二叉树的层次、总节点数, 也需要递归. 以后可能要用, 这里就一并写了.

题目一：二叉树的前序遍历
输出：二叉树前序遍历序列
示例：

a b d f g c e

题目二：二叉树的中序遍历
输出：二叉树中序遍历序列
示例：

b f d g a e c

题目二：二叉树的后序遍历
输出：二叉树后序遍历序列
示例：

f g d b e c a

题目三：求二叉树的深度
输出：二叉树深度

The depth is: 4

题目四：求二叉树的结点个数
输出：二叉树结点个数

The number of nodes is : 7

代码如下：

package datastructure.tree;

/**
 * 
 * @author Ling Lin E-mail:linling0.0@foxmail.com
 * 
 * @version 创建时间：2022年4月17日 下午3:37:46
 * 
 */
public class BinaryCharTree {

	// The value in char.
	char value;

	// The left child.
	BinaryCharTree leftChild;

	// The right child.
	BinaryCharTree rightChild;

	/**
	 * The first constructor.
	 * 
	 * @param paraName
	 *            The value.
	 */
	public BinaryCharTree(char paraName) {
		value = paraName;
		leftChild = null;
		rightChild = null;
	}// Of the constructor

	/*
	 * Manually construct a tree. Only for testing.
	 */
	public static BinaryCharTree manualConstructTree() {
		// Step 1. Construct a tree with only one node.
		BinaryCharTree resultTree = new BinaryCharTree('a');

		// Step 2. Construct all nodes. The first node is the root.
		// BinaryCharTreeNode tempTreeA = resultTree.root;
		BinaryCharTree tempTreeB = new BinaryCharTree('b');
		BinaryCharTree tempTreeC = new BinaryCharTree('c');
		BinaryCharTree tempTreeD = new BinaryCharTree('d');
		BinaryCharTree tempTreeE = new BinaryCharTree('e');
		BinaryCharTree tempTreeF = new BinaryCharTree('f');
		BinaryCharTree tempTreeG = new BinaryCharTree('g');

		// Step 3. Link all nodes.
		resultTree.leftChild = tempTreeB;
		resultTree.rightChild = tempTreeC;
		tempTreeB.rightChild = tempTreeD;
		tempTreeC.leftChild = tempTreeE;
		tempTreeD.leftChild = tempTreeF;
		tempTreeD.rightChild = tempTreeG;

		return resultTree;
	}// Of manualConstructTree

	/**
	 * Pre-order visit.
	 * 
	 * @param args
	 */
	public void preOrderVisit() {
		System.out.print("" + value + " ");

		if (leftChild != null) {
			leftChild.preOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.preOrderVisit();
		} // Of if
	}// Of preOrderVisit

	/**
	 * In-order visit
	 * 
	 * @param args
	 */
	public void inOrderVisit() {
		if (leftChild != null) {
			leftChild.inOrderVisit();
		} // Of if

		System.out.print("" + value + " ");

		if (rightChild != null) {
			rightChild.inOrderVisit();
		} // Of if
	}// Of inOrderVisit

	/**
	 *********************
	 * Post-order visit.
	 *********************
	 */
	public void postOrderVisit() {
		if (leftChild != null) {
			leftChild.postOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.postOrderVisit();
		} // Of if

		System.out.print("" + value + " ");
	}// Of postOrderVisit

	/**
	 * Get the depth of the binary tree.
	 * 
	 * @return The depth. It is 1 if there is only one node, i.e, the root.
	 */
	public int getDepth() {
		// It is a leaf.
		if ((leftChild == null) && rightChild == null) {
			return 1;
		} // Of if

		// The depth of the left child.
		int tempLeftDepth = 0;
		if (leftChild != null) {
			tempLeftDepth = leftChild.getDepth();
		} // Of if

		// The depth of the right child.
		int tempRightDepth = 0;
		if (rightChild != null) {
			tempRightDepth = rightChild.getDepth();
		} // Of if

		// The depth should increment by 1.
		if (tempLeftDepth >= tempRightDepth) {
			return tempLeftDepth + 1;
		} else {
			return tempRightDepth + 1;
		} // Of if
	}// Of getDepth

	/**
	 * Get the number of nodes.
	 * 
	 * @return The number of nodes.
	 * 
	 */
	public int getNumNodes() {
		// It is a leaf.
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		} // Of if

		// The number of nodes of the left child.
		int tempLeftNodes = 0;
		if (leftChild != null) {
			tempLeftNodes = leftChild.getNumNodes();
		} // Of if

		// The number of nodes of the left child.
		int tempRightNodes = 0;
		if (rightChild != null) {
			tempRightNodes = rightChild.getNumNodes();
		} // Of if

		// The total number of nodes.
		return tempLeftNodes + tempRightNodes + 1;
	}// Of getNumNodes

	/**
	 * The entrance of the program.
	 * 
	 * @param args
	 *            Not used now.
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BinaryCharTree tempTree = manualConstructTree();

		System.out.println("\r\nPreorder visit:");
		tempTree.preOrderVisit();

		System.out.println("\r\nIn-order visit:");
		tempTree.inOrderVisit();

		System.out.println("\r\nPost-order visit:");
		tempTree.postOrderVisit();

		System.out.println("\r\n\r\nThe depth is: " + tempTree.getDepth());
		System.out.println("The number of nodes is : " + tempTree.getNumNodes());

	}// Of main

}// Of BinaryCharTree

运行结果：
在这里插入图片描述

二、二叉树的存储

二叉树的存储并非一个简单的问题. 引用 (指针) 是无法存储到文件里面的.
我们可以从完全满二叉树的角度广度优先遍历的角度来考虑这个问题: 每个节点都有一个 name 及其在二叉树中的位置. 令根节点的位置为 0; 则第 2 层节点的位置依次为 1 至 2; 第 3 层节点的位置依次为 3 至 6. 以此类推.
把昨天那个例子所对应的二叉树画出来, 我们有两种方法:

空使用 0 来表示, 可以用一个向量来存储:
[a, b, c, 0, d, e, 0, 0, 0, f, g]
优点: 仅需要一个向量, 简单直接.
缺点: 对于实际的二叉树, 很多子树为空, 导致大量的 0 值.
刘知鑫指出: 应使用压缩存储方式, 即将节点的位置和值均存储. 可表示为两个向量:

[0, 1, 2, 4, 5, 9, 10]
[a, b, c, d, e, f, g]

由于递归程序涉及变量的作用域问题 (额, 这个真的有点头疼), 我们需要使用层次遍历的方式, 获得以上的几个向量. 为此, 需要用到队列. 我们先灌点水, 把队列的代码再写一遍, 但这次装的是对象 (的引用).
代码如下：

package datastructure.queue;

/**
 * 
 * @author Ling Lin E-mail:linling0.0@foxmail.com
 * 
 * @version 创建时间：2022年4月17日 下午4:37:53
 * 
 */
public class CircleObjectQueue {

	// The total space. One space can never be used.
	public static final int TOTAL_SPACE = 10;

	// The data.
	Object[] data;

	// The index of the head.
	int head;

	// The index of the tail.
	int tail;

	/**
	 * The constructor
	 */
	public CircleObjectQueue() {
		data = new Object[TOTAL_SPACE];
		head = 0;
		tail = 0;
	}//Of the first constructor

	/**
	 * Enqueue.
	 * 
	 * @param paraValue
	 *            The value of the new node.
	 */
	public void enqueue(Object paraValue) {
		if ((tail + 1) % TOTAL_SPACE == head) {
			System.out.println("Queue full.");
			return;
		}//Of if

		data[tail % TOTAL_SPACE] = paraValue;
		tail++;
	}//Of enqueue

	/*
	 * Dequeue.
	 * 
	 * @return The value at the head.
	 */
	public Object dequeue() {
		if (head == tail) {
			//System.out.println("No element in the queue");
			return null;
		}//Of if

		Object resultValue = data[head % TOTAL_SPACE];

		head++;

		return resultValue;
	}//Of dequeue

	/**
	 * Overrides the method claimed in Object, the superclass of any class.
	 */
	@Override
	public String toString() {
		String resultString = "";

		if (head == tail) {
			return "empty";
		}//Of if

		for (int i = head; i < tail; i++) {
			resultString += data[i % TOTAL_SPACE] + ", ";
		}//Of for i

		return resultString;
	}//Of toString

	/**
	 * The entrance of the program.
	 * 
	 * @param args
	 *            Not used now.
	 */
	public static void main(String args[]) {
		CircleObjectQueue tempQueue = new CircleObjectQueue();
	}//Of main

}//Of CircleObjectQueue

数据转换的代码很短, 但要理解还是比较花时间.
用了两个队列.
实际上涵盖了广度优先 (或称层次) 遍历.
节点左儿子的编号是其编号 2 倍再加 1; 右儿子则应加 2.
main 前面的保留, 只是为了读者方便与前面的程序对标.
需要 import datastructure.queue.*;

如下：

package datastructure.tree;

import java.util.Arrays;

import datastructure.queue.CircleIntQueue;
import datastructure.queue.CircleObjectQueue;

/**
 * 
 * @author Ling Lin E-mail:linling0.0@foxmail.com
 * 
 * @version 创建时间：2022年4月17日 下午3:37:46
 * 
 */
public class BinaryCharTree {

	// The value in char.
	char value;

	// The left child.
	BinaryCharTree leftChild;

	// The right child.
	BinaryCharTree rightChild;

	/**
	 * The first constructor.
	 * 
	 * @param paraName
	 *            The value.
	 */
	public BinaryCharTree(char paraName) {
		value = paraName;
		leftChild = null;
		rightChild = null;
	}// Of the constructor

	/*
	 * Manually construct a tree. Only for testing.
	 */
	public static BinaryCharTree manualConstructTree() {
		// Step 1. Construct a tree with only one node.
		BinaryCharTree resultTree = new BinaryCharTree('a');

		// Step 2. Construct all nodes. The first node is the root.
		// BinaryCharTreeNode tempTreeA = resultTree.root;
		BinaryCharTree tempTreeB = new BinaryCharTree('b');
		BinaryCharTree tempTreeC = new BinaryCharTree('c');
		BinaryCharTree tempTreeD = new BinaryCharTree('d');
		BinaryCharTree tempTreeE = new BinaryCharTree('e');
		BinaryCharTree tempTreeF = new BinaryCharTree('f');
		BinaryCharTree tempTreeG = new BinaryCharTree('g');

		// Step 3. Link all nodes.
		resultTree.leftChild = tempTreeB;
		resultTree.rightChild = tempTreeC;
		tempTreeB.rightChild = tempTreeD;
		tempTreeC.leftChild = tempTreeE;
		tempTreeD.leftChild = tempTreeF;
		tempTreeD.rightChild = tempTreeG;

		return resultTree;
	}// Of manualConstructTree

	/**
	 * Pre-order visit.
	 * 
	 * @param args
	 */
	public void preOrderVisit() {
		System.out.print("" + value + " ");

		if (leftChild != null) {
			leftChild.preOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.preOrderVisit();
		} // Of if
	}// Of preOrderVisit

	/**
	 * In-order visit
	 * 
	 * @param args
	 */
	public void inOrderVisit() {
		if (leftChild != null) {
			leftChild.inOrderVisit();
		} // Of if

		System.out.print("" + value + " ");

		if (rightChild != null) {
			rightChild.inOrderVisit();
		} // Of if
	}// Of inOrderVisit

	/**
	 *********************
	 * Post-order visit.
	 *********************
	 */
	public void postOrderVisit() {
		if (leftChild != null) {
			leftChild.postOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.postOrderVisit();
		} // Of if

		System.out.print("" + value + " ");
	}// Of postOrderVisit

	/**
	 * Get the depth of the binary tree.
	 * 
	 * @return The depth. It is 1 if there is only one node, i.e, the root.
	 */
	public int getDepth() {
		// It is a leaf.
		if ((leftChild == null) && rightChild == null) {
			return 1;
		} // Of if

		// The depth of the left child.
		int tempLeftDepth = 0;
		if (leftChild != null) {
			tempLeftDepth = leftChild.getDepth();
		} // Of if

		// The depth of the right child.
		int tempRightDepth = 0;
		if (rightChild != null) {
			tempRightDepth = rightChild.getDepth();
		} // Of if

		// The depth should increment by 1.
		if (tempLeftDepth >= tempRightDepth) {
			return tempLeftDepth + 1;
		} else {
			return tempRightDepth + 1;
		} // Of if
	}// Of getDepth

	/**
	 * Get the number of nodes.
	 * 
	 * @return The number of nodes.
	 * 
	 */
	public int getNumNodes() {
		// It is a leaf.
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		} // Of if

		// The number of nodes of the left child.
		int tempLeftNodes = 0;
		if (leftChild != null) {
			tempLeftNodes = leftChild.getNumNodes();
		} // Of if

		// The number of nodes of the left child.
		int tempRightNodes = 0;
		if (rightChild != null) {
			tempRightNodes = rightChild.getNumNodes();
		} // Of if

		// The total number of nodes.
		return tempLeftNodes + tempRightNodes + 1;
	}// Of getNumNodes

	// The values of nodes according to breadth first traversal.
	char[] valuesArray;

	// The indices in the complete binary tree.
	int[] indicesArray;

	/**
	 * Convert the tree to data arrays, including a char array and an int array.
	 * The results are stored in two member variables.
	 * 
	 * @see #valuesArray
	 * @see #indicesArray
	 */
	public void toDataArrays() {
		// Initialize arrays.
		int tempLength = getNumNodes();

		valuesArray = new char[tempLength];
		indicesArray = new int[tempLength];
		int i = 0;

		// Traverse and convert at the same time.
		CircleObjectQueue tempQueue = new CircleObjectQueue();
		tempQueue.enqueue(this);
		CircleIntQueue tempIntQueue = new CircleIntQueue();
		tempIntQueue.enqueue(0);

		BinaryCharTree tempTree = (BinaryCharTree) tempQueue.dequeue();
		int tempIndex = tempIntQueue.dequeue();
		while(tempTree != null){
			valuesArray[i] = tempTree.value;
			indicesArray[i] = tempIndex;
			i++;//!!!

			if(tempTree.leftChild != null){
				tempQueue.enqueue(tempTree.leftChild);
				tempIntQueue.enqueue(tempIndex * 2 + 1);
			} // Of if

			if(tempTree.rightChild != null){
				tempQueue.enqueue(tempTree.rightChild);
				tempIntQueue.enqueue(tempIndex * 2 + 2);
			} // Of if

			tempTree = (BinaryCharTree) tempQueue.dequeue();
			tempIndex = tempIntQueue.dequeue();
		}//Of while
	}//Of toDataArrays

	/**
	 *********************
	 * The entrance of the program.
	 * 
	 * @param args
	 *            Not used now.
	 *********************
	 */
	public static void main(String args[]) {
		BinaryCharTree tempTree = manualConstructTree();
		System.out.println("\r\nPreorder visit:");
		tempTree.preOrderVisit();
		System.out.println("\r\nIn-order visit:");
		tempTree.inOrderVisit();
		System.out.println("\r\nPost-order visit:");
		tempTree.postOrderVisit();

		System.out.println("\r\n\r\nThe depth is: " + tempTree.getDepth());
		System.out.println("The number of nodes is: " + tempTree.getNumNodes());

		tempTree.toDataArrays();
		System.out.println("The values are: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("The indices are: " + Arrays.toString(tempTree.indicesArray));
	}// Of main

}// Of class BinaryCharTree

运行结果：
在这里插入图片描述

阿柠·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树之二叉搜索树
GadyPu的专栏
10-29 515
简单的实现了一下二叉搜索
Java入门基础学习资料day11
10-22
此java基础课程，适合0基础小白，课程一共11天...day11【final、权限、内部类、引用类型】 此课程全部课程资料获取： JavaEE基础学习资料地址汇总：https://blog.csdn.net/weixin_46271129/article/details/133979063
二叉树与链表之间的转换
stay hungry,stay foolish
12-11 2130
一、单链表转换为二叉树 // C++ program to create a Complete Binary tree from its Linked List // Representation #include #include #include using namespace std; // Linked list node struct ListNode { int d
LinkNode
海阔天空
08-17 3768
#include struct node { int data; node *next; node() { next = NULL; } }; node *head; void addLink() { node *now = head; while(now->next) { now = now
LeetCode 刷题笔记 （树）
dianche1354的博客
06-05 131
1.minimum-depth-of-binary-tree 题目描述 Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf ...
二叉树两种遍历方式
头发茂密的假程序猿
03-02 200
1. 自定义树TreeNode public class TreeNode { private String value; private TreeNode right; private TreeNode left; public String getValue() { return value; } public void setValue(String value) { this.value = value;
【springboot】springboot学习笔记day11
guaishounan的博客
03-11 5745
springboot学习笔记day11.xmind-Java文档类资源-CSDN下载
day11课上代码.py
07-10
day11课上代码.py
嵌入式学习-01C语言day11
03-14
嵌入式学习-01C语言day11
day11函数进阶.py
09-08
day11函数进阶.py
day11-多线程 java
06-10
day11-多线程 java
构建个简单的LinkNode
橘子hhh
11-02 1646
由于java中没有结构体，所以用一个类来定义链表，代码如下 主要包括一个data，还有一个指向后面一个节点的next 重写了toString函数，返回你想要的数据 定义链表的类： public class LinkNode { private String data; public LinkNode next; public String getData() { return data; } public void setData
python数据结构第八章课后习题答案（三）
weixin_44272011的博客
09-15 531
8.61 class Tree: """Abstract base class representing a tree structure.""" # ----------------------------nested Position class ----------------------------- class Position: """An abstraction representing the location of a single element
链表实例应用
laugh哥的博客
09-04 1395
一：只实现链表的增加与访问 class Link{ private class Node{//内部类Node private String data; private Node next; public Node(String data) { this.data=data; } public void addNode(Node newNode) {//增加节点 if(this.next=
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 1043
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
JAVA基础：数据类型、命名规范
最新发布
weixin_53755148的博客
09-05 1143
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 494
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1018
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
weixin_53180424的博客
09-03 962
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
Warning[Pe177]: variable "pTxData" was declared but never referenced D:\桌面\无线节点\Day11BasicRF\project\collect.c 22
05-24
这个警告是在编译代码时产生的，它告诉你在文件"D:\桌面\无线节点\Day11BasicRF\project\collect.c"中，第22行声明的变量"pTxData"从未被引用。这意味着你声明了一个变量，但在代码的后续部分中没有使用它。为了消除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值