java中二叉树_JAVA中的二叉树（数据结构）

二叉树的遍历

代码实现

package tree;

/**

* 二叉树

* 前序中序后序遍历实现

*/

public class BinaryTreeDemo {

public static void main(String[] args) {

//先需要创建一颗二叉树

BinaryTree binaryTree = new BinaryTree();

//创建需要的节点

HeroNode heroNode1 = new HeroNode(1, "松江1");

HeroNode heroNode2 = new HeroNode(2, "松江2");

HeroNode heroNode3 = new HeroNode(3, "松江3");

HeroNode heroNode4 = new HeroNode(4, "松江4");

HeroNode heroNode5 = new HeroNode(5, "松江5");

//说明：我们先手动创建该二叉树，后面再用递归的方式创建二叉树

heroNode1.setLeft(heroNode2);

heroNode1.setRight(heroNode3);

heroNode3.setRight(heroNode4);

heroNode3.setLeft(heroNode5);

binaryTree.setRoot(heroNode1);

//测试

System.out.println("前序遍历");//1 2 3 5 4

binaryTree.perOrder();

System.out.println("中序遍历");//2 1 5 3 4

binaryTree.infixOrder();

System.out.println("后序遍历");// 2 5 4 3 1

binaryTree.postOrder();

}

}

//定义BinaryTree 二叉树

class BinaryTree {

private HeroNode root;

public void setRoot(HeroNode root) {

this.root = root;

}

//前序遍历

public void perOrder(){

if(this.root!=null) {

this.root.preOrder();

}else{

System.out.println("二叉树为空，无法遍历");

}

}

//中序遍历

public void infixOrder(){

if(this.root!=null){

this.root.infixOrder();

}else{

System.out.println("二叉树为空，无法中序遍历");

}

}

//后序遍历

public void postOrder(){

if(this.root!=null){

this.root.postOrder();

}else{

System.out.println("二叉树为空,无法后续遍历");

}

}

}

//先创建HeroNode节点

class HeroNode{

private int no;

private String name;

private HeroNode left;//默认Null

private HeroNode right; //默认null

@Override

public String toString() {

return "HeroNode{" +

"no=" + no +

", name='" + name + '\'' +

'}';

}

public HeroNode(int no, String name) {

this.no = no;

this.name=name;

}

public int getNo() {

return no;

}

public void setNo(int no) {

this.no = no;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public HeroNode getLeft() {

return left;

}

public void setLeft(HeroNode left) {

this.left = left;

}

public HeroNode getRight() {

return right;

}

public void setRight(HeroNode right) {

this.right = right;

}

//编写前序遍历的方法

public void preOrder(){

System.out.println(this);//先输出父节点

//递归向左子树前序遍历

if(this.left != null){

this.left.preOrder();

}

//递归向右子树前序遍历

if(this.right != null){

this.right.preOrder();

}

}

//中序遍历

public void infixOrder(){

//递归向左子树中序遍历

if(this.left != null){

this.left.infixOrder();

}

//输出当前节点

System.out.println(this);

//递归向右子树中序遍历

if(this.right != null){

this.right.infixOrder();

}

}

//后续遍历

public void postOrder(){

//递归向左子树后续遍历

if(this.left != null){

this.left.postOrder();

//            System.out.println("现在是左边的节点"+this.left);

}

//递归向右子树后续遍历

if(this.right != null){

this.right.postOrder();

//            System.out.println("现在是右边的节点"+this.right);

}

//输出当前节点

System.out.println(this);

}

}

//

遍历查找二叉树

其实查找和遍历的思想是差不多的 这里我就不细述

/**

* 前序遍历查找

* 如果找到就返回Node，如果没有找到就返回null

*/

public HeroNode PreOrderSearch(int no) {

System.out.println("前序查找运行啦");

//比较当前节点是不是

if (this.getNo() == no) {

return this;

}

//判断当前节点的左子节点是否为空，如果不为空，则递归前序查找

//如果左递归前序查找，找到节点，则返回

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.PreOrderSearch(no);

}

if (resNode != null) {

//说明我们左子树找到

return resNode;

}

//右递归前序查找，找到节点，则返回，否则继续判断

//当前的节点的右子节点是否为空，如果不空，则继续向右递归前序查找

if (this.right != null) {

resNode = this.right.PreOrderSearch(no);

}

//在这里无论找没找到都需要返回

return resNode;

}

/**

* 中序遍历查找

*/

public HeroNode InfixOrderSearch(int no) {

//判断当前节点的左子节点是否为空

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.InfixOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

System.out.println("中序查找运行啦");

//判断当前节点

if (this.no == no) {

return this;

}

//否则继续进行右递归

if (this.right != null) {

resNode = this.right.InfixOrderSearch(no);

}

return resNode;

}

/**

* 后序遍历查找

*/

public HeroNode PostOrderSearch(int no) {

//判断当前的左节点是否为空

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.PostOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

//判断当前的右节点是否为空

if (this.right != null) {

resNode = this.right.PostOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

System.out.println("后序查找运行啦");

//判断当前节点

if (this.getNo() == no) {

return this;

}

return resNode;

}

删除二叉树的节点

在这里判断的一定是当前节点的子节点是否为需要删除的节点

第一种，删除节点包括节点后的子节点

这里我写了两种方法，不过两种方法的实现其实都是一样的

//递归删除节点

//如果删除的节点是叶子节点，则删除该节点

//如果删除的节点是非叶子节点，则删除该子树

public void delNode(int no) {

//如果当前节点的左子节点不为空

if (this.left != null && this.left.getNo() == no) {

this.left = null;

return;

}

//如果当前节点的右子节点不为空

if (this.right != null && this.right.getNo() == no) {

this.right = null;

return;

}

//如果前面没删除成功，那就继续递归删除

if (this.left != null) {

this.left.delNode(no);

}

//继续右递归删除

if (this.right != null) {

this.right.delNode(no);

}

}

//删除节点

public boolean deleteNode(int id) {

//判断当前节点的左节点是否为要删除的节点

if (this.left != null && this.left.getNo() == id) {

System.out.println("左节点删除成功！" + this.left.getName());

this.left = null;

return true;

}

if (this.right != null && this.right.getNo() == id) {

System.out.println("右节点删除成功！" + this.right.getName());

this.right = null;

return true;

}

if (this.left != null && this.left.deleteNode(id)) {

return true;

} else if (this.right != null && this.right.deleteNode(id)) {

return true;

}

return false;

}

第二种删除方法

//删除节点(只删除单节点)

public void delNodeOne(int id) {

//如果当前节点的左子节点不为空

if (this.left != null && this.left.getNo() == id) {

System.out.println("这是第一次判断"+this.left.getName());

if(this.left.left!=null || this.left.right!=null){

if(this.left.left!=null){

this.left=this.left.left;

return;

}else{

this.left=this.left.right;

return;

}

}else{

this.left=null;

return;

}

}

//如果当前节点的右子节点不为空

if (this.right != null && this.right.getNo() == id) {

System.out.println("这是第二次判断"+this.right.getName());

if(this.right.left!=null || this.right.right!=null){

if(this.right.left!=null){

this.right=this.right.left;

return;

}else{

this.right=this.right.right;

return;

}

}else{

this.right=null;

return;

}

}

//如果前面没删除成功，那就继续递归删除

if (this.left != null) {

System.out.println("开始左递归了"+this.left.getName());

this.left.delNodeOne(no);

}

//继续右递归删除

if (this.right != null) {

System.out.println("开始右递归了"+this.right.getName());

this.right.delNodeOne(no);

}

}

我这里写的代码可能冗余很大，如果有更简便的方法，欢迎指正！

完整代码

package tree;

/**

* 二叉树

* 前序中序后序遍历实现

*/

public class BinaryTreeDemo {

public static void main(String[] args) {

//先需要创建一颗二叉树

BinaryTree binaryTree = new BinaryTree();

//创建需要的节点

HeroNode heroNode1 = new HeroNode(1, "松江1");

HeroNode heroNode2 = new HeroNode(2, "林冲2");

HeroNode heroNode3 = new HeroNode(3, "吴用3");

HeroNode heroNode4 = new HeroNode(4, "李逵4");

HeroNode heroNode5 = new HeroNode(5, "卢俊义5");

//说明：我们先手动创建该二叉树，后面再用递归的方式创建二叉树

heroNode1.setLeft(heroNode2);

heroNode1.setRight(heroNode3);

heroNode3.setRight(heroNode4);

heroNode3.setLeft(heroNode5);

binaryTree.setRoot(heroNode1);

//测试

//        System.out.println("前序遍历");//1 2 3 5 4

//        binaryTree.perOrder();

//        System.out.println("中序遍历");//2 1 5 3 4

//        binaryTree.infixOrder();

//        System.out.println("后序遍历");// 2 5 4 3 1

//        binaryTree.postOrder();

//

//        //前序遍历查找

//        System.out.println("前序遍历查找方式");

//        HeroNode resNode = binaryTree.perorderSearch(5);

//        if (resNode != null) {

//            System.out.println("找到了" + resNode.getNo() + resNode.getName());

//        } else {

//            System.out.println("没有找到");

//        }

//        //中序遍历查找

//        System.out.println("中序遍历查找方式");

//        HeroNode resNode1 = binaryTree.infixOrderSearch(5);

//        if (resNode != null) {

//            System.out.println("找到了" + resNode.getNo() + resNode.getName());

//        } else {

//            System.out.println("没有找到");

//        }

//        //后序遍历查找

//        System.out.println("后序遍历查找方式");

//        HeroNode resNode2 = binaryTree.postorderSearch(5);

//        if (resNode != null) {

//            System.out.println("找到了" + resNode.getNo() + resNode.getName());

//        } else {

//            System.out.println("没有找到");

//        }

//        //测试删除节点

//        binaryTree.deleteNode(5);

//        binaryTree.perOrder();

//删除前

System.out.println("删除前");

binaryTree.perOrder();

binaryTree.delNodeOne(3);

//        binaryTree.delNode(5);

System.out.println("删除后");

binaryTree.perOrder();

}

}

//定义BinaryTree 二叉树

class BinaryTree {

private HeroNode root;

public void setRoot(HeroNode root) {

this.root = root;

}

//前序遍历

public void perOrder() {

if (this.root != null) {

this.root.preOrder();

} else {

System.out.println("二叉树为空，无法遍历");

}

}

//中序遍历

public void infixOrder() {

if (this.root != null) {

this.root.infixOrder();

} else {

System.out.println("二叉树为空，无法中序遍历");

}

}

//后序遍历

public void postOrder() {

if (this.root != null) {

this.root.postOrder();

} else {

System.out.println("二叉树为空,无法后续遍历");

}

}

//前序遍历查找

public HeroNode perorderSearch(int no) {

if (root != null) {

return root.PreOrderSearch(no);

} else {

return null;

}

}

//中序遍历查找

public HeroNode infixOrderSearch(int no) {

if (root != null) {

return root.InfixOrderSearch(no);

} else {

return null;

}

}

//后序遍历

public HeroNode postorderSearch(int no) {

if (root != null) {

return root.PostOrderSearch(no);

} else {

return null;

}

}

//删除节点(二)

public void delNode(int no) {

if (root != null) {

//如果只有一个root节点，这里立即判断root是不是要删除的节点

if (root.getNo() == no) {

root = null;

} else {

//递归删除

root.delNode(no);

}

} else {

System.out.println("空树 无法删除!");

}

}

//删除节点

public void deleteNode(int id) {

//判断是否为空树

if (root == null) {

System.out.println("树是空树");

return;

}

//判断根节点root是否为要删除节点

if (root.getNo() == id) {

System.out.println("删除根节点");

root = null;

return;

}

if (root.deleteNode(id)) {

return;

} else {

System.out.println("没有该节点");

}

}

//删除单节点

public void delNodeOne(int no) {

if (root != null) {

//如果只有一个root节点，这里立即判断root是不是要删除的节点

if (root.getNo() == no) {

root = null;

} else {

//递归删除

root.delNodeOne(no);

}

} else {

System.out.println("空树 无法删除!");

}

}

}

//先创建HeroNode节点

class HeroNode {

private int no;

private String name;

private HeroNode left;//默认Null

private HeroNode right; //默认null

@Override

public String toString() {

return "HeroNode{" +

"no=" + no +

", name='" + name + '\'' +

'}';

}

public HeroNode(int no, String name) {

this.no = no;

this.name = name;

}

public int getNo() {

return no;

}

public void setNo(int no) {

this.no = no;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public HeroNode getLeft() {

return left;

}

public void setLeft(HeroNode left) {

this.left = left;

}

public HeroNode getRight() {

return right;

}

public void setRight(HeroNode right) {

this.right = right;

}

//编写前序遍历的方法

public void preOrder() {

System.out.println(this);//先输出父节点

//递归向左子树前序遍历

if (this.left != null) {

this.left.preOrder();

}

//递归向右子树前序遍历

if (this.right != null) {

this.right.preOrder();

}

}

//中序遍历

public void infixOrder() {

//递归向左子树中序遍历

if (this.left != null) {

this.left.infixOrder();

}

//输出当前节点

System.out.println(this);

//递归向右子树中序遍历

if (this.right != null) {

this.right.infixOrder();

}

}

//后续遍历

public void postOrder() {

//递归向左子树后续遍历

if (this.left != null) {

this.left.postOrder();

//            System.out.println("现在是左边的节点"+this.left);

}

//递归向右子树后续遍历

if (this.right != null) {

this.right.postOrder();

//            System.out.println("现在是右边的节点"+this.right);

}

//输出当前节点

System.out.println(this);

}

/**

* 前序遍历查找

* 如果找到就返回Node，如果没有找到就返回null

*/

public HeroNode PreOrderSearch(int no) {

System.out.println("前序查找运行啦");

//比较当前节点是不是

if (this.getNo() == no) {

return this;

}

//判断当前节点的左子节点是否为空，如果不为空，则递归前序查找

//如果左递归前序查找，找到节点，则返回

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.PreOrderSearch(no);

}

if (resNode != null) {

//说明我们左子树找到

return resNode;

}

//右递归前序查找，找到节点，则返回，否则继续判断

//当前的节点的右子节点是否为空，如果不空，则继续向右递归前序查找

if (this.right != null) {

resNode = this.right.PreOrderSearch(no);

}

//在这里无论找没找到都需要返回

return resNode;

}

/**

* 中序遍历查找

*/

public HeroNode InfixOrderSearch(int no) {

//判断当前节点的左子节点是否为空

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.InfixOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

System.out.println("中序查找运行啦");

//判断当前节点

if (this.no == no) {

return this;

}

//否则继续进行右递归

if (this.right != null) {

resNode = this.right.InfixOrderSearch(no);

}

return resNode;

}

/**

* 后序遍历查找

*/

public HeroNode PostOrderSearch(int no) {

//判断当前的左节点是否为空

HeroNode resNode = null;

if (this.left != null) {

resNode = this.left.PostOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

//判断当前的右节点是否为空

if (this.right != null) {

resNode = this.right.PostOrderSearch(no);

}

if (resNode != null) {

return resNode;

}

System.out.println("后序查找运行啦");

//判断当前节点

if (this.getNo() == no) {

return this;

}

return resNode;

}

//递归删除节点

//如果删除的节点是叶子节点，则删除该节点

//如果删除的节点是非叶子节点，则删除该子树

public void delNode(int no) {

//如果当前节点的左子节点不为空

if (this.left != null && this.left.getNo() == no) {

this.left = null;

return;

}

//如果当前节点的右子节点不为空

if (this.right != null && this.right.getNo() == no) {

this.right = null;

return;

}

//如果前面没删除成功，那就继续递归删除

if (this.left != null) {

this.left.delNode(no);

}

//继续右递归删除

if (this.right != null) {

this.right.delNode(no);

}

}

//删除节点

public boolean deleteNode(int id) {

//判断当前节点的左节点是否为要删除的节点

if (this.left != null && this.left.getNo() == id) {

System.out.println("左节点删除成功！" + this.left.getName());

this.left = null;

return true;

}

if (this.right != null && this.right.getNo() == id) {

System.out.println("右节点删除成功！" + this.right.getName());

this.right = null;

return true;

}

if (this.left != null && this.left.deleteNode(id)) {

return true;

} else if (this.right != null && this.right.deleteNode(id)) {

return true;

}

return false;

}

//删除节点(只删除单节点)

public void delNodeOne(int id) {

//如果当前节点的左子节点不为空

if (this.left != null && this.left.getNo() == id) {

System.out.println("这是第一次判断"+this.left.getName());

if(this.left.left!=null || this.left.right!=null){

if(this.left.left!=null){

this.left=this.left.left;

return;

}else{

this.left=this.left.right;

return;

}

}else{

this.left=null;

return;

}

}

//如果当前节点的右子节点不为空

if (this.right != null && this.right.getNo() == id) {

System.out.println("这是第二次判断"+this.right.getName());

if(this.right.left!=null || this.right.right!=null){

if(this.right.left!=null){

this.right=this.right.left;

return;

}else{

this.right=this.right.right;

return;

}

}else{

this.right=null;

return;

}

}

//如果前面没删除成功，那就继续递归删除

if (this.left != null) {

System.out.println("开始左递归了"+this.left.getName());

this.left.delNodeOne(no);

}

//继续右递归删除

if (this.right != null) {

System.out.println("开始右递归了"+this.right.getName());

this.right.delNodeOne(no);

}

}

}

//

上述资料引用自尚硅谷