java简单二叉树,用Java实现一颗简单的二叉树

什么是二叉树？

实现一颗简单的二叉树

TreeNode

二叉树的结点。

package com.lzhpo.twotree;

/**

* 二叉树

*

*

* Create By IntelliJ IDEA

* Author：lzhpo

*

*/

public class TreeNode {

//节点的权

int value;

//左儿子

TreeNode leftNode;

//右儿子

TreeNode rightNode;

/**

* 二叉树的创建

*/

//构造方法，传入一个值

public TreeNode(int value) {

this.value = value;

}

//设置左儿子

public void setlNode(TreeNode lNode) {

this.leftNode = lNode;

}

//设置右儿子

public void setrNode(TreeNode rNode) {

this.rightNode = rNode;

}

/**

* 二叉树的遍历

*/

//前序遍历(根，左，右)

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 setleftNode(TreeNode lNode) {

this.leftNode = lNode;

}

//设置右孩子

public void setrightNode(TreeNode rNode) {

this.rightNode = rNode;

}

/**

* 二叉树的查找

*/

//前序查找

public TreeNode frontSearch(int i) {

TreeNode target=null;

//对比当前节点的值

if(this.value==i)

{

return this;

//当前节点中的值不是要查找的

}else {

//查找左节点

if(leftNode!=null)

{

//有可能可以查到，有可能查找不到，查不到的话，target还是null

target=leftNode.frontSearch(i);

}

//如果不为空，则查找成功

if(target!=null) {

return target;

}

//查找右节点

if(rightNode!=null)

{

target=rightNode.frontSearch(i);

}

}

return target;

}

/**

* 二叉树的删除

*/

//删除二叉树的子树

public void delete(int i) {

TreeNode parent=this;

//判断左孩子

if(parent.leftNode!=null&&parent.leftNode.value==i)

{

parent.leftNode=null;

return;

}

//判断右孩子

if(parent.rightNode!=null&&parent.rightNode.value==i)

{

parent.rightNode=null;

return;

}

//如果都不是,递归检查并删除左孩子

parent=leftNode;

if(parent!=null)

{

parent.delete(i);

}

//递归检查并删除右孩子

parent=rightNode;

if(parent!=null)

{

parent.delete(i);

}

}

}

BinaryTree

实现二叉树的相关简单操作。

package com.lzhpo.twotree;

/**

*

* Create By IntelliJ IDEA

* Author：lzhpo

*

*/

public class BinaryTree {

//根节点

TreeNode root;

/**

* 二叉树的创建

*/

//获取根节点

public TreeNode getRoot() {

return root;

}

//设置根节点

public void setRoot(TreeNode root) {

this.root = root;

}

/**

* 二叉树的遍历

*/

//前序遍历

public void frontShow()

{

if(root!=null) {

root.frontShow();

}else

{

System.out.println("此二叉树为空");

}

}

//中序遍历

public void midShow()

{

if(root!=null) {

root.midShow();

}else

{

System.out.println("此二叉树为空");

}

}

//后序遍历

public void afterShow()

{

if(root!=null) {

root.afterShow();

}else

{

System.out.println("此二叉树为空");

}

}

/**

* 二叉树的查找

* @param i

* @return

*/

//前序查找

public TreeNode frontSearch(int i) {

return root.frontSearch(i);

}

/**

* 二叉树的删除

* @param i

*/

public void delete(int i) {

if(root.value==i)

{

root=null;

}else {

root.delete(i);

}

}

}

TestBinaryTree

main方法。

package com.lzhpo.twotree;

/**

*

* Create By IntelliJ IDEA

* Author：lzhpo

*

*/

public class TestBinaryTree {

public static void main(String[] args) {

/**

* 创建二叉树

*/

//创建一棵树

BinaryTree binaryTree = new BinaryTree();

//创建一个根节点

TreeNode root = new TreeNode(1);

//把根节点赋给树

binaryTree.setRoot(root);

//创建两个节点

TreeNode rootL = new TreeNode(2);

TreeNode rootR = new TreeNode(3);

//把心创建的节点设置为根节点的子节点

root.setlNode(rootL);

root.setrNode(rootR);

//为第二层的节点创建子节点

rootL.setleftNode(new TreeNode(4));

rootL.setrightNode(new TreeNode(5));

rootR.setleftNode(new TreeNode(6));

rootR.setrightNode(new TreeNode(7));

/**

* 遍历二叉树

*/

System.out.println("======================二叉树的遍历======================");

//1.前序遍历(根，左，右)

System.out.println("此二叉树的前序遍历为：");

binaryTree.frontShow();

System.out.println();

System.out.println("此二叉树的中序遍历为：");

binaryTree.midShow();

System.out.println();

System.out.println("此二叉树的后序遍历为：");

binaryTree.afterShow();

/**

* 二叉树的查找

*/

System.out.println("======================二叉树的查找======================");

TreeNode result = binaryTree.frontSearch(9);

System.out.println(result);

/**

* 二叉树删除

*/

System.out.println("======================二叉树的删除======================");

binaryTree.delete(2);

binaryTree.frontShow();

}

}