二叉树节点
/**
* 节点
* @author Administrator
*
*/
public class Node {
/**
* 数据
*/
public int data;
/**
* 左孩子
*/
public Node leftChild;
/**
* 右孩子
*/
public Node rightChild;
public Node() {}
public Node(int data, Node leftChild, Node rightChild) {
this.data = data;
this.leftChild = leftChild;
this.rightChild = rightChild;
}
}
先序遍历
/**
* 先序遍历
* 按照根 左 右 的顺序
*/
public void preOrderTraverse(Node root, List list) {
if (root != null) {
// 根
list.add(root.data);
// 遍历左子树
this.preOrderTraverse(root.leftChild, list);
// 遍历右子树
this.preOrderTraverse(root.rightChild, list);
}
}
中序遍历
/**
* 中序遍历
* 按照 左 根 右 的顺序
*/
public void inOrderTraverse(Node root, List list) {
if (root != null) {
// 遍历左子树
this.inOrderTraverse(root.leftChild, list);
// 根
list.add(root.data);
// 遍历右子树
this.inOrderTraverse(root.rightChild, list);
}
}
后序遍历
/**
* 后序遍历
* 按照 左 右 根 的顺序
*/
public void postOrderTraverse(Node root, List list) {
if (root != null) {
// 遍历左子树
this.postOrderTraverse(root.leftChild, list);
// 遍历右子树
this.postOrderTraverse(root.rightChild, list);
// 根
list.add(root.data);
}
}
层次遍历
public List levelOrderTraverse() {
// 如果树为空直接返回
if (root == null) {
return null;
}
List list = new ArrayList();
Queue<Node> queue = new LinkedList();
// 根节点入队列
queue.add(root);
while (queue.size() > 0) { // 队列不为空
Node p = queue.poll();
list.add(p.data);
if (p.leftChild != null) { // 左孩子入队
queue.add(p.leftChild);
}
if (p.rightChild != null) { // 右孩子入队
queue.add(p.rightChild);
}
}
return list;
}
节点个数
/**
* 计算节点个数
* 左子树 + 右子树 + 1
*/
public int size(Node root) {
if (root == null) {
return 0;
}
// 计算左子树节点个数
int ls = size(root.leftChild);
// 计算右子树节点个数
int rs = size(root.rightChild);
// 返回左子树节点个数+右子树结点个数+1
return ls + rs + 1;
}
树的深度
/**
* 计算树的深度
* 左子树与右子树深度较大的那个 + 1
*/
public int height(Node root) {
if (root == null) {
return 0;
}
// 计算左子树深度
int lh = height(root.leftChild);
// 计算右子树深度
int rh = height(root.rightChild);
// 返回左子树与右子树深度较大的那个 + 1
return (lh > rh ? lh : rh) + 1;
}
二叉树统一接口
import java.util.List;
/**
* 二叉树统一的接口
* @author Administrator
*
*/
public interface BinaryTree {
/**
* 先序遍历
* @return
*/
List preOrderTraverse();
/**
* 中序遍历
* @return
*/
List inOrderTraverse();
/**
* 后序遍历
* @return
*/
List postOrderTraverse();
/**
* 层次遍历
* @return
*/
List levelOrderTraverse();
/**
* 节点个数
* @return
*/
int size();
/**
* 树的深度
* @return
*/
int height();
}
二叉树接口具体的实现类
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 自定义二叉树
* 底层使用二叉链表实现
* @author Administrator
*
*/
public class ListBinaryTree implements BinaryTree {
private Node root;
public ListBinaryTree() {}
public ListBinaryTree(Node root) {
this.root = root;
}
public void setRoot(Node root) {
this.root = root;
}
@Override
public List preOrderTraverse() {
List list = new ArrayList();
preOrderTraverse(root, list);
return list;
}
/**
* 先序遍历
* 按照根 左 右 的顺序
*/
public void preOrderTraverse(Node root, List list) {
if (root != null) {
// 根
list.add(root.data);
// 遍历左子树
this.preOrderTraverse(root.leftChild, list);
// 遍历右子树
this.preOrderTraverse(root.rightChild, list);
}
}
@Override
public List inOrderTraverse() {
List list = new ArrayList();
inOrderTraverse(root, list);
return list;
}
/**
* 中序遍历
* 按照 左 根 右 的顺序
*/
public void inOrderTraverse(Node root, List list) {
if (root != null) {
// 遍历左子树
this.inOrderTraverse(root.leftChild, list);
// 根
list.add(root.data);
// 遍历右子树
this.inOrderTraverse(root.rightChild, list);
}
}
@Override
public List postOrderTraverse() {
List list = new ArrayList();
postOrderTraverse(root, list);
return list;
}
/**
* 后序遍历
* 按照 左 右 根 的顺序
*/
public void postOrderTraverse(Node root, List list) {
if (root != null) {
// 遍历左子树
this.postOrderTraverse(root.leftChild, list);
// 遍历右子树
this.postOrderTraverse(root.rightChild, list);
// 根
list.add(root.data);
}
}
@Override
public List levelOrderTraverse() {
// 如果树为空直接返回
if (root == null) {
return null;
}
List list = new ArrayList();
Queue<Node> queue = new LinkedList();
// 根节点入队列
queue.add(root);
while (queue.size() > 0) { // 队列不为空
Node p = queue.poll();
list.add(p.data);
if (p.leftChild != null) { // 左孩子入队
queue.add(p.leftChild);
}
if (p.rightChild != null) { // 右孩子入队
queue.add(p.rightChild);
}
}
return list;
}
@Override
public int size() {
return size(root);
}
/**
* 计算节点个数
* 左子树 + 右子树 + 1
*/
public int size(Node root) {
if (root == null) {
return 0;
}
// 计算左子树节点个数
int ls = size(root.leftChild);
// 计算右子树节点个数
int rs = size(root.rightChild);
// 返回左子树节点个数+右子树结点个数+1
return ls + rs + 1;
}
@Override
public int height() {
return height(root);
}
/**
* 计算树的深度
* 左子树与右子树深度较大的那个 + 1
*/
public int height(Node root) {
if (root == null) {
return 0;
}
// 计算左子树深度
int lh = height(root.leftChild);
// 计算右子树深度
int rh = height(root.rightChild);
// 返回左子树与右子树深度较大的那个 + 1
return (lh > rh ? lh : rh) + 1;
}
}
测试类
import java.util.ArrayList;
import java.util.List;
public class TestBinaryTree {
public static void main(String[] args) {
// 创建二叉树
Node node7 = new Node(7, null, null);
Node node6 = new Node(6, null, node7);
Node node3 = new Node(3, null, null);
Node node5 = new Node(5, null, null);
Node node4 = new Node(4, null, node5);
Node node2 = new Node(2, node3, node6);
Node node1 = new Node(1, node4, node2);
ListBinaryTree btree = new ListBinaryTree(node1);
// 先序遍历 1 4 5 2 3 6 7
List<Integer> preList = new ArrayList<Integer>();
preList = btree.preOrderTraverse();
System.out.print("先序遍历:");
for (int t: preList) {
System.out.print(" " + t);
}
System.out.println();
// 中序遍历 4 5 1 3 2 6 7
List<Integer> inList = new ArrayList<Integer>();
inList = btree.inOrderTraverse();
System.out.print("中序遍历:");
for (int t: inList) {
System.out.print(" " + t);
}
System.out.println();
// 后序遍历 5 4 3 7 6 2 1
List<Integer> postList = new ArrayList<Integer>();
postList = btree.postOrderTraverse();
System.out.print("后序遍历:");
for (int t: postList) {
System.out.print(" " + t);
}
System.out.println();
// 层次遍历 1 4 2 5 3 6 7
List<Integer> levelList = new ArrayList<Integer>();
levelList = btree.levelOrderTraverse();
System.out.print("层次遍历:");
for (int t: levelList) {
System.out.print(" " + t);
}
System.out.println();
// 二叉树的高度 4
System.out.println("深度: " + btree.height());
// 二叉树的节点个数 7
System.out.println("节点个数: " + btree.size());
}
}
结果
先序遍历: 1 4 5 2 3 6 7
中序遍历: 4 5 1 3 2 6 7
后序遍历: 5 4 3 7 6 2 1
层次遍历: 1 4 2 5 3 6 7
深度: 4
节点个数: 7