java binarytreenode_Java Binary Tree && 链式存储结构

Java Binary Tree && 链式存储结构

以下使用二叉链表的方式实现，具体代码

package binarytree;

/**

* 二叉树的二叉链表表示

*/

public class BinaryTree {

private TreeNode root;  //根节点

public BinaryTree() {

}

public BinaryTree(TreeNode root) {

this.root = root;

}

/**

* 定义节点

* 内部类

*/

private static class TreeNode {

private T data = null;  // 数据部分

private TreeNode lchild;  // 左节点的引用

private TreeNode rchild; // 右节点的引用

protected TreeNode() {

}

protected TreeNode(T data, TreeNode lchild, TreeNode rchild) {

this.data = data;

this.lchild = lchild;

this.rchild = rchild;

}

private T getData() {

return data;

}

private void setData(T data) {

this.data = data;

}

private TreeNode getLchild() {

return lchild;

}

private void setLchild(TreeNode lchild) {

this.lchild = lchild;

}

private TreeNode getRchild() {

return rchild;

}

private void setRchild(TreeNode rchild) {

this.rchild = rchild;

}

}

/**

* 返回父结点

*

* @param element

* @return

*/

public TreeNode getParent(TreeNode element) {

//如果传入参数为根节点或根节点为空，返回null

return (root == null || root == element) ? null : parent(root, element);

}

/**

* @param subTree

* @param element

* @return

*/

public TreeNode parent(TreeNode subTree, TreeNode element) {

if (subTree == null) {

return null;

}

//如果subTree的左孩子节点或右孩子节点等于element，则返回subTree

if (subTree.getLchild() == element || subTree.getRchild() == element) {

// 返回父结点地址

return subTree;

}

TreeNode p;

// 现在左子树中找，如果左子树中没有找到，才到右子树去找

if ((p = parent(subTree.getLchild(), element)) != null) {

// 递归在左子树中搜索

return p;

} else {

// 递归在右子树中搜索

return parent(subTree.getRchild(), element);

}

}

/**

* 节点个数

*

* @return

*/

public int getSize() {

return getNum(root);

}

private int getNum(TreeNode node) {

if (node == null) {

return 0;

} else {

int i = getNum(node.getLchild());

int j = getNum(node.getRchild());

return j + i + 1;

}

}

/**

* 树高度

*

* @return

*/

public int getHeight() {

return getHeight(root);

}

private int getHeight(TreeNode tree) {

if (tree == null)

return 0;// 递归结束：空树高度为0

else {

int i = getHeight(tree.getLchild());

int j = getHeight(tree.getRchild());

return (i 

}

}

/**

* 前序遍历

* 先访问根结点，然后遍历左子树，最后遍历右子树

*

* @param node

*/

public void preOrder(TreeNode node) {

if (node != null) {

System.out.println(node.getData());

preOrder(node.getLchild());

preOrder(node.getRchild());

}

}

/**

* 中序遍历

* 首先遍历左子树，然后访问根结点，最后遍历右子树

*

* @param node

*/

public void inOrder(TreeNode node) {

if (node != null) {

preOrder(node.getLchild());

System.out.println(node.getData());

preOrder(node.getRchild());

}

}

/**

* 后序遍历

* 首先遍历左子树，然后遍历右子树，最后遍历访问根结点

*

* @param node

*/

public void postOrder(TreeNode node) {

if (node != null) {

preOrder(node.getLchild());

preOrder(node.getRchild());

System.out.println(node.getData());

}

}

public static void main(String[] args) {

TreeNode n1 = new TreeNode("1", null, null);   // 没有左右孩子节点

TreeNode n2 = new TreeNode("2", null, null);   // 没有左右孩子节点

TreeNode n3 = new TreeNode("3", null, n2);  // 根节点左子树

TreeNode n4 = new TreeNode("4", null, n1); // 根节点右子树

TreeNode root = new TreeNode("root", n3, n4);   // 创建根节点

BinaryTree bt = new BinaryTree(root);

System.out.println("=======先序遍历======");

bt.preOrder(bt.root);

System.out.println("=======中序遍历======");

bt.inOrder(bt.root);

System.out.println("========后续遍历=======");

bt.postOrder(bt.root);

System.out.println("===========");

System.out.println(bt.getHeight());

System.out.println(bt.getSize());

System.out.println(bt.getParent(n1).getData());

}

}

构造的树的示意图

共有五个节点的二叉树

程序运行结果：

=======先序遍历======

root

3

2

4

1

=======中序遍历======

3

2

root

4

1

========后续遍历=======

3

2

4

1

root

===========

3

5

4

=======END=======