java数组转二叉树-前序遍历-中序遍历-后序遍历-层序遍历

二叉树定义：

二叉树是每个节点最多有两个子树的树结构。

它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。



图1-1

二叉树按照其子树的分布状态，又出现两个特殊的二叉树：满二叉树，完全二叉树。

满二叉树：所有的分支结点都存在左子树和右子树，并且所有的叶子结点都在同一层上，这样就是满二叉树。满二叉树见下图：



图1-2

完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。满二叉树必须是完全二叉树，反过来不一定成立。完全二叉树见下图：



图1-3

二叉树的性质

一般二叉树：

*第n层最多有2^(n-1)个节点。*

深度为k的二叉树 最多有节点 2^k - 1个。

*对于任何一颗二叉树 如果其叶节点有n个 度为2的非叶节点有m个 则有 n = m + 1。*

具有n个节点的完全二叉树的高度为 [lgN + 1]（log以2为底） [X]表示不大于X的最大整数。

一个有n个节点的二叉树 (lgN+1 2为底) 按层次对节点进行编号(从上到下 从左到右)对任意节点有。

满二叉树：

如果对满二叉树按1-n编号，设某节点为n,那么该满二叉树的左孩子节点为2*n+1，右孩子节点为2*i+2。

如果对满二叉树按1-n编号，设总节点为n个,可以得出最后一个非叶子节点为n/2 向下取整

二叉树的遍历

1、深度优先：

前序遍历：先根节点，再遍历左孩子节点，再遍历右孩子节点。利用递归实现。（图1-3，遍历后：0-1-3-7-8-4-2-5-6）

中序遍历：先左孩子节点，再遍历根节点，再遍历右孩子节点。利用递归实现。（图1-3，遍历后：7-3-8-1-4-0-5-2-6）

后序遍历：先左孩子节点，再遍历右孩子节点，再遍历左孩子节点。利用递归实现。（图1-3，遍历后：7-8-3-4-1-5-6-2-0）

注意：前三种遍历是以深度优先，比如前序遍历，同一层节点，左孩子没有遍历结束，不会遍历右孩子。可以利用栈模仿递归，实现这三种遍历

2、广度优先：

层序遍历，将二叉树按照层，逐层遍历数据，借助队列（先进先出）实现。（图1-3，遍历后：0-1-2-3-4-5-6-7-8）

数组转二叉树、二叉树遍历和测试代码如下：

package tree;
import java.util.ArrayList
cb84
;
import java.util.LinkedList;
import java.util.Queue;

public class BinaryTree {
public int data;// value
public static ArrayList<BinaryTree> temps;// 构造二叉树临时数据
public BinaryTree left = null;// 左子树
public BinaryTree right = null;// 右子数

// 数组转二叉树
public static BinaryTree arraysToTree(int arrays[]) {
if (arrays.length == 0) {
return null;
}
int length = arrays.length;

// 生成二叉树节点
temps = new ArrayList<BinaryTree>(length);
for (int i = 0; i < length; i++) {
BinaryTree node = new BinaryTree();
node.data = arrays[i];
temps.add(node);

}
// 构建二叉树 根节点n[i] 左子树n[i*2+1] 右子树 n[i*2+2]
for (int i = 0; i < length / 2 - 1; i++) {
BinaryTree node = temps.get(i);
node.left = temps.get(2 * i + 1);
node.right = temps.get(2 * i + 2);

}
// 处理最后一个节点
int lastNode = length / 2 - 1;
BinaryTree node = temps.get(lastNode);
// 添加左子树
node.left = temps.get(lastNode * 2 + 1);

if (length % 2 != 0) {
// 当为偶数时，添加右子树
node.right = temps.get(lastNode * 2 + 2);
}

BinaryTree root = temps.get(0);
temps.clear();
temps = null;
return root;

}

// 前序遍历打印二叉树
public static void prOrderTree(BinaryTree node) {
if (node == null) {
return;
}
System.out.print("\t" + node.data);
// 左子树
BinaryTree left = node.left;
// 打印节点信息
if (left != null) {
prOrderTree(left);
}
// 右子树
BinaryTree right = node.right;
if (right != null) {
prOrderTree(right);
}

}

// 中序遍历
public static void inOrderTree(BinaryTree node) {
if (node == null) {
return;
}
// 左子树
BinaryTree left = node.left;
if (left != null) {
inOrderTree(left);
}
// 打印节点信息
System.out.print("\t" + node.data);
// 右子树
BinaryTree right = node.right;
if (right != null) {
inOrderTree(right);
}

}

// 后序遍历
public static void postOrderTree(BinaryTree node) {
if (node == null) {
return;
}
// 左子树
BinaryTree left = node.left;
if (left != null) {
postOrderTree(left);
}
// 右子树
BinaryTree right = node.right;
if (right != null) {
postOrderTree(right);
}
// 打印节点信息
System.out.print("\t" + node.data);

}

// 层序遍历
public static void levelOrderTree(BinaryTree node) {

if (node == null) {
return;
}
Queue<BinaryTree> queue = new LinkedList<BinaryTree>();// 队列
queue.offer(node);
while (!queue.isEmpty()) {

BinaryTree root = queue.poll();
// 输出内容
System.out.print("\t" + root.data);

// 左子树
BinaryTree left = root.left;
if (left != null) {
queue.offer(left);
}
// 右子树
BinaryTree right = root.right;
if (right != null) {
queue.offer(right);
}

}

}

}

// 测试代码

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
int arrays []=new int [8];
for(int i =0;i<arrays.length;i++){
arrays[i]= i;
}
BinaryTree binaryTree = BinaryTree.arraysToTree(arrays);
System.out.println("前序遍历：");
BinaryTree.prOrderTree(binaryTree);
System.out.println("\n中序遍历：");
BinaryTree.inOrderTree(binaryTree);
System.out.println("\n后序遍历：");
BinaryTree.postOrderTree(binaryTree);
System.out.println("\n层序遍历：");
BinaryTree.levelOrderTree(binaryTree);
}

}

测试结果：



希望对你有所帮助。。。