参考:https://blog.csdn.net/autfish/article/details/52535967
1.什么是完全二叉树
1.除二叉树最后一层外,其他各层的节点数都达到最大个数
2.最后一层从左向右的叶节点连续存在,只缺右侧若干节点,就是完全二叉树。
如下图,每一层都是从左向右摆放节点,每个节点都是摆满两个子节点后才向右移动到下一个节点,一层摆满后向下移动一层,直到摆放完所有数字。这样得到的二叉树就是完全二叉树,中间有任何缺失的节点就不能称为完全二叉树。
特点:如果一个父节点的编号是x,那么它左子节点的编号就是2x,右子节点的编号就是2x+1
对于x个节点组成的二叉树,只有前x / 2(取整)个节点具有子节点,且第x / 2个节点可能只有左子节点。
先序遍历(DLR):称为先根次序遍历,即先访问根节点,再按先序遍历左子树,最后按先序遍历右子树。
中序遍历(LDR):称为中根次序遍历,即先按中序遍历左子树,再访问根节点,最后按中序遍历右子树。
后序遍历(LRD):称为后根次序遍历,即先按后序遍历左子树,再按后序遍历右子树,最后访问根节点。
import java.util.LinkedList;
import java.util.List;
/**
* Created by autfish on 2016/9/13.
*/
public class BinTreeByList {
List<Node> nodes = null;
private int[] datas = null;
private int number;
public BinTreeByList(int[] datas) {
this.datas = datas;
this.number = this.datas.length;
}
public void create() {
nodes = new LinkedList<>();
for(int i = 0; i < this.number; i++) {
nodes.add(new Node(datas[i]));
}
//如果父节点编号为x, 那么左子节点的编号是2x, 右子节点的编号是2x+1
for(int noteId = 1; noteId <= this.number / 2; noteId++) {
//索引从0开始, 需要在节点编号上减1
nodes.get(noteId - 1).leftChild = nodes.get(noteId * 2 - 1);
if(noteId * 2 < this.number)
nodes.get(noteId - 1).rightChild = nodes.get(noteId * 2);
}
}
private static class Node {
Node leftChild;
Node rightChild;
int data;
public Node(int data) {
this.data = data;
}
}
}
/**
*遍历
*/
public void preOrder(Node node) {
if(node == null) {
return;
}
System.out.print(node.data + " ");
preOrder(node.leftChild);
preOrder(node.rightChild);
}
public void inOrder(Node node) {
if(node == null) {
return;
}
inOrder(node.leftChild);
System.out.print(node.data + " ");
inOrder(node.rightChild);
}
public void postOrder(Node node) {
if(node == null) {
return;
}
postOrder(node.leftChild);
inOrder(node.rightChild);
System.out.print(node.data + " ");
}
完全二叉树还有一种更简单的存储方式,即一维数组。也就是说int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}本身就是一个完全二叉树了。
根据数字在数组中的索引即可以计算出数字的节点位置,而且仍然可以对这个二叉树做三种方式的遍历。
/**
* 完全二叉树
* Created by autfish on 2016/9/8.
*/
public class BinTreeByArray {
private int[] numbers;
public BinTreeByArray(int[] numbers) {
this.numbers = numbers;
}
/**
* 先序遍历
* 根节点 -> 遍历左子树 -> 遍历右子树
* @param nodeId
*/
public void preOrder(int nodeId) {
if(nodeId <= numbers.length) {
System.out.print(numbers[nodeId - 1] + " ");
preOrder(nodeId * 2);
preOrder(nodeId * 2 + 1);
}
}
/**
* 中序遍历
* 左子树 -> 父节点 -> 右子树
* @param nodeId
*/
public void inOrder(int nodeId) {
if(nodeId <= numbers.length) {
inOrder(nodeId * 2);
System.out.print(numbers[nodeId - 1] + " ");
inOrder(nodeId * 2 + 1);
}
}
/**
* 后续遍历
* 左子树 -> 右子树 -> 父节点
* @param nodeId
*/
public void postOrder(int nodeId) {
if(nodeId <= numbers.length) {
postOrder(nodeId * 2);
inOrder(nodeId * 2 + 1);
System.out.print(numbers[nodeId - 1] + " ");
}
}
public static void main(String[] args) {
int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
for(int x = 0; x < numbers.length; x++) {
System.out.print(numbers[x] + " ");
}
System.out.println();
BinTreeByArray tree = new BinTreeByArray(numbers);
System.out.print("先序遍历");
tree.preOrder(1);
System.out.println();
System.out.print("中序遍历");
tree.inOrder(1);
System.out.println();
System.out.print("后续遍历");
tree.postOrder(1);
}
}