二叉树的构建及遍历
1、二叉树的构建及遍历
二叉树的遍历：
- 前序遍历
- 中序遍历
- 后续遍历
- 层次遍历
Node 类
package com.bennett.test0930;
import java.util.LinkedList;
/**
* @version:1.0
* @Description:二叉树结点类
* @author bennett
* @date: 2021年10月5日 下午10:50:44
*/
public class Node {
Integer value;
private Node leftNode;// 左结点
private Node rightNode;// 右结点
// 构造方法
public Node(Integer value) {
super();
this.value = value;
}
// set方法（设置左右结点）
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
// 前序遍历
public void frontShow() {
// 先遍历根节点
System.out.print(value + " ");
// 左节点
if (leftNode != null) {
leftNode.frontShow();
}
// 右节点
if (rightNode != null) {
rightNode.frontShow();
}
}
// 中序遍历
public void midShow() {
if (leftNode != null) {
leftNode.midShow();
}
System.out.print(value + " ");
if (rightNode != null) {
rightNode.midShow();
}
}
// 后序遍历
public void afterShow() {
if (leftNode != null) {
leftNode.afterShow();
}
if (rightNode != null) {
rightNode.afterShow();
}
System.out.print(value + " ");
}
// 层次遍历
public void levelShow(Node node) {
LinkedList<Node> list = new LinkedList<Node>();
list.add(node);
Node currentNode;
while (!list.isEmpty()) {
currentNode = list.poll(); // 获取并移除此列表的头
System.out.print(currentNode.value+" ");
if (null != currentNode.leftNode) {
list.add(currentNode.leftNode);
}
if (null != currentNode.rightNode) {
list.add(currentNode.rightNode);
}
}
}
// 查询结点
public Node search(int i) {
Node target = null;
if (this.value == i) {
return this;
} else {
if (leftNode != null) {
target = leftNode.search(i);
}
if (target != null) {
return target;
}
if (rightNode != null) {
target = rightNode.search(i);
}
}
return target;
}
// 删除结点
public void delete(int i) {
Node parent = this;
if (parent.leftNode != null && parent.leftNode.value == i) {
parent.leftNode = null;
}
if (parent.rightNode != null && parent.rightNode.value == i) {
parent.rightNode = null;
}
parent = leftNode;
if (parent != null) {
parent.delete(i);
}
parent = rightNode;
if (parent != null) {
parent.delete(i);
}
}
@Override
public String toString() {
return this.value + " ";
}
}
BinaryTree 类
package com.bennett.test0930;
/**
* @version:1.0
* @Description:二叉树
* @author bennett
* @date: 2021年10月5日 下午10:51:07
*/
public class BinaryTree {
private Node rootNode;
// 设置根结点
public void setRootNode(Node rootNode) {
this.rootNode = rootNode;
}
// 获得根结点
public Node getRootNode() {
return rootNode;
}
// 前序遍历
public void frontShow() {
if (rootNode != null) {
rootNode.frontShow();
}
}
// 中序遍历
public void midShow() {
if (rootNode != null) {
rootNode.midShow();
}
}
// 后序遍历
public void afterShow() {
if (rootNode != null) {
rootNode.afterShow();
}
}
// 层次遍历
public void levelShow() {
if (rootNode != null) {
rootNode.levelShow(rootNode);
}
}
// 查询结点
public Node search(int i) {
return rootNode.search(i);
}
// 删除结点
public void delete(int i) {
if (rootNode.value == i) {
rootNode = null;
} else {
rootNode.delete(i);
}
}
}
package com.bennett.test0930;
/**
* @version:1.0
* @Description:二叉树测试类
* @author bennett
* @date: 2021年10月5日 下午10:51:20
*/
public class BinaryTreeTest {
public static void main(String[] args) {
// 创建一棵树(空树，没有结点）
BinaryTree binaryTree = new BinaryTree();
// 创建一个根节点
Node root = new Node(1);
// 把根节点赋值给树
binaryTree.setRootNode(root);
// 创建左节点
Node lNode = new Node(2);
// 将新创建的结点设置为根节点的左结点
root.setLeftNode(lNode);
// 创建右节点
Node rNode = new Node(3);
// 将新创建的结点设置为根节点的右结点
root.setRightNode(rNode);
// 为2创建两个结点
lNode.setLeftNode(new Node(4));
lNode.setRightNode(new Node(5));
// 为3创建两个结点
rNode.setLeftNode(new Node(6));
rNode.setRightNode(new Node(7));
// 前序遍历
System.out.println("前序遍历: ");
binaryTree.frontShow();
System.out.println();
// 中序遍历
System.out.println("中序遍历：");
binaryTree.midShow();
System.out.println();
// 后序遍历
System.out.println("后序遍历：");
binaryTree.afterShow();
System.out.println();
//层次遍历
System.out.println("层次遍历:");
binaryTree.levelShow();
System.out.println("");
// 查找元素
System.out.println("查找元素：");
Node result = binaryTree.search(5);
System.out.println(result);
// 删除结点
System.out.println("删除元素3");
binaryTree.delete(3);
binaryTree.frontShow();
}
}
2、二叉树的构建及遍历
BinTree<T>类
package com.bennett.test1006;
public class BinTree<T> {
private Node<T> root;
// 结点类
static class Node<T>{
private T value;
// 父节点
private Node<T> parent;
// 左子树
private Node<T> leftChild;
// 右子树
private Node<T> rightChild;
public Node(T value) {
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
// 初始化
boolean initial(T value) {
if(root!=null) return false;
root=new Node<>(value);
return true;
}
// 添加左子树
boolean addLeft(Node<T> parent,Node<T> node) {
if(parent==null) return false;
parent.leftChild=node;
return true;
}
// 添加右子树
boolean addRight(Node<T> parent,Node<T> node) {
if(parent==null) return false;
parent.rightChild=node;
return true;
}
void itertor(Node<T> root,int level) {
// 前序遍历
StringBuilder prefix=new StringBuilder();
for (int i = 0; i < level; i++) {
prefix.append("--");
}
prefix.append(" ");
System.out.println(prefix.toString()+root.getValue());//根节点
// System.out.println("-- "+root.leftChild.value);//左子树
if(root.leftChild!=null) {
itertor(root.leftChild,level+1);
}
// 中序遍历
// StringBuilder prefix=new StringBuilder();
// for (int i = 0; i < level; i++) {
// prefix.append("--");
// }
// prefix.append(" ");
// System.out.println(prefix.toString()+root.getValue());//根节点
if(root.rightChild!=null) {
itertor(root.rightChild,level+1);
}
// System.out.println("-- "+root.rightChild.value);
// 后续遍历
// StringBuilder prefix=new StringBuilder();
// for (int i = 0; i < level; i++) {
// prefix.append("--");
// }
// prefix.append(" ");
// System.out.println(prefix.toString()+root.getValue());//根节点
}
public Node<T> getRoot() {
return root;
}
public void setRoot(Node<T> root) {
this.root = root;
}
public static void main(String[] args) {
// 创建树
BinTree<Integer> tree=new BinTree<>();
tree.initial(1);
// 构建树的结点
Node<Integer> node1 =new Node<>(-1);
tree.addLeft(tree.getRoot(),node1);
Node<Integer> node2 =new Node<>(2);
tree.addRight(tree.getRoot(),node2);
Node<Integer> node11 =new Node<>(-11);
tree.addLeft(node1,node11);
Node<Integer> node12 =new Node<>(-2);
tree.addRight(node1,node12);
// 打印树（前中后序遍历根据输出根节点的位置）
tree.itertor(tree.getRoot(),0);
}
}
练习题
用树结构存储如图所示的信息，图有点模糊，但关键是其结构，信息下面代码中有。
方式一
package com.bennett.test0930;
import java.util.LinkedList;
/**
* @version:
* @Description:结构树的结点
* @author bennett
* @date: 2021年10月5日 下午10:52:10
*/
public class StringNode {
private String value;
private StringNode node1;
private StringNode node2;
private StringNode node3;
private StringNode node4;
public StringNode(String value) {
super();
this.value = value;
}
public void setNode1(StringNode node1) {
this.node1 = node1;
}
public void setNode2(StringNode node2) {
this.node2 = node2;
}
public void setNode3(StringNode node3) {
this.node3 = node3;
}
public void setNode4(StringNode node4) {
this.node4 = node4;
}
// 层次遍历
public void levelShow(StringNode node) {
LinkedList<StringNode> list = new LinkedList<StringNode>();
list.add(node);
StringNode currentNode;
while (!list.isEmpty()) {
currentNode = list.poll(); // 获取并移除此列表的头
System.out.println(currentNode.value+" ");
if (null != currentNode.node1) {
list.add(currentNode.node1);
}
if (null != currentNode.node2) {
list.add(currentNode.node2);
}
if (null != currentNode.node3) {
list.add(currentNode.node3);
}
if (null != currentNode.node4) {
list.add(currentNode.node4);
}
}
}
}
package com.bennett.test0930;
/**
* @version:
* @Description:结构树
* @author bennett
* @date: 2021年10月5日 下午10:51:40
*/
public class StringTree {
private StringNode rootNode;
public StringNode getRootNode() {
return rootNode;
}
public void setRootNode(StringNode rootNode) {
this.rootNode = rootNode;
}
// 层次遍历
public void levelShow() {
if (rootNode != null) {
rootNode.levelShow(rootNode);
}
}
}
package com.bennett.test0930;
/**
* @version:
* @Description:结构树的测试类
* @author bennett
* @date: 2021年10月5日 下午10:52:29
*/
public class StringTreeTest {
public static void main(String[] args) {
StringTree stringTree = new StringTree();
// 创建结点
// 前三层
StringNode rootNode = new StringNode("股东大会");
stringTree.setRootNode(rootNode);
StringNode level_2_node1 = new StringNode("董事会");
rootNode.setNode1(level_2_node1);
StringNode level_3_node1 = new StringNode("CEO（总经理）");
level_2_node1.setNode1(level_3_node1);
// 第四层
StringNode level_4_node1 = new StringNode("副总经理1");
level_3_node1.setNode1(level_4_node1);
StringNode level_4_node2 = new StringNode("副总经理2");
level_3_node1.setNode2(level_4_node2);
StringNode level_4_node3 = new StringNode("副总经理3");
level_3_node1.setNode3(level_4_node3);
// 第五层
StringNode level_5_node1 = new StringNode("办公室");
StringNode level_5_node2 = new StringNode("企划部");
StringNode level_5_node3 = new StringNode("人力资源部");
StringNode level_5_node4 = new StringNode("市场拓展部");
level_4_node1.setNode1(level_5_node1);
level_4_node1.setNode2(level_5_node2);
level_4_node1.setNode3(level_5_node3);
level_4_node1.setNode4(level_5_node4);
StringNode level_5_node5 = new StringNode("营运部");
StringNode level_5_node6 = new StringNode("销售部");
StringNode level_5_node7 = new StringNode("品控部");
level_4_node2.setNode1(level_5_node5);
level_4_node2.setNode2(level_5_node6);
level_4_node2.setNode3(level_5_node7);
StringNode level_5_node8 = new StringNode("采购部");
StringNode level_5_node9 = new StringNode("工程部");
StringNode level_5_node10 = new StringNode("中央厨房");
StringNode level_5_node11 = new StringNode("研发部");
level_4_node3.setNode1(level_5_node8);
level_4_node3.setNode2(level_5_node9);
level_4_node3.setNode3(level_5_node10);
level_4_node3.setNode4(level_5_node11);
// 第六层
StringNode level_6_node1 = new StringNode("培训部");
StringNode level_6_node2 = new StringNode("档案部");
StringNode level_6_node3 = new StringNode("招聘部");
level_5_node3.setNode1(level_6_node1);
level_5_node3.setNode2(level_6_node2);
level_5_node3.setNode3(level_6_node3);
StringNode level_6_node4 = new StringNode("快餐事业部");
StringNode level_6_node5 = new StringNode("中餐事业部");
level_5_node6.setNode1(level_6_node4);
level_5_node6.setNode2(level_6_node5);
StringNode level_6_node6 = new StringNode("设备维养部");
StringNode level_6_node7 = new StringNode("工程筹建部");
level_5_node9.setNode1(level_6_node6);
level_5_node9.setNode2(level_6_node7);
StringNode level_6_node8 = new StringNode("物流部");
StringNode level_6_node9 = new StringNode("加工中心");
level_5_node10.setNode1(level_6_node8);
level_5_node10.setNode1(level_6_node9);
// 第七层
StringNode level_7_node1 = new StringNode("分店一");
StringNode level_7_node2 = new StringNode("分店二");
StringNode level_7_node3 = new StringNode("分店三");
level_6_node4.setNode1(level_7_node1);
level_6_node4.setNode2(level_7_node2);
level_6_node4.setNode3(level_7_node3);
StringNode level_7_node4 = new StringNode("分店一");
StringNode level_7_node5 = new StringNode("分店二");
StringNode level_7_node6 = new StringNode("分店三");
level_6_node5.setNode1(level_7_node4);
level_6_node5.setNode2(level_7_node5);
level_6_node5.setNode3(level_7_node6);
// 层次遍历
System.out.println("层次遍历该树：");
stringTree.levelShow();
System.out.println();
}
}
方式二
package com.bennett.test1006;
import java.util.ArrayList;
import java.util.List;
/**
* @version:
* @Description:结构树的测试类
* @author bennett
* @date: 2021年10月6日 下午10:52:29
*/
public class CompanysTest {
static class Company{
private String title;
private Company parent;
private List<Company> childs;
public Company(String title, Company parent) {
this.title = title;
this.parent = parent;
if(parent!=null ) {
if(parent.childs==null) {
parent.childs=new ArrayList<>();
}
parent.childs.add(this);
}
}
}
public static void main(String[] args) {
Company root=new Company("股东大会", null);
// List<Company> list=new ArrayList<>();
Company company1=new Company("董事会", root);
Company company2=new Company("监事会", root);
// list.add(company1);
// list.add(company2);
// root.childs=list;
Company company11=new Company("总经理", company1);
Company company12=new Company("财务部", company1);
Company company111=new Company("副总经理", company11);
Company company112=new Company("副总经理", company11);
Company company113=new Company("副总经理", company11);
Company company1111=new Company("办公室", company111);
Company company1112=new Company("企划部", company111);
Company company1113=new Company("人力资源部", company111);
Company company1114=new Company("市场拓展部", company111);
Company company1121=new Company("营运部", company112);
Company company1122=new Company("销售部", company112);
Company company1123=new Company("品控部", company112);
Company company1131=new Company("采购部", company113);
Company company1132=new Company("工程部", company113);
Company company1133=new Company("中央厨房", company113);
Company company1134=new Company("研发部", company113);
showCompanys(root,0);
}
private static void showCompanys(Company company, int level) {
StringBuilder prefix=new StringBuilder();
for (int i = 0; i < level; i++) {
prefix.append("--");
}
System.out.println(prefix+company.title);
if(company.childs==null) return;
for (Company subCompany : company.childs) {
showCompanys(subCompany,level+1);
}
}
}
7886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
