最近闲来无事，研究了一下二叉树。怪了，非平衡二叉树，两三个小时就搞定了生成方法，以及几个相关的小方法。但是到了平衡二叉树，愣是把我折磨的两天，都卡在左旋转和右旋转那里了。不过因祸得福啊，两天后，正在为了旋转抓头挠腮的我，灵光一闪，半个小时就把旋转那一块完成了。毕竟折磨了两天多，不能让成果浪费，现在分享出来。
树的概念
树是一种数据结构，是由多个节点对象按照一定顺序组成的数据结构。
如上图，
1、节点A是根节点。
2、节点B是节点A的左子节点。
3、节点C是节点A的右子节点。
4、节点A是节点B和节点C的父节点。
另外，根据上图这个满二叉树，还可以看出二叉树的规律还有：
1、每个节点最多有2个子节点。
2、每个节点最多只有1个父节点（根节点没有父节点）。
3、每层的最大节点数为：(2^(L-1))个（L代表第几层）。
4、一个二叉树的最大节点数为：（2^T – 1）（T代表最大层数）
树的作用
要说树的作用，还是要用上图的满二叉树来举例。
图中共有15个节点对象，如果放在集合List（数组）中，那么我要随机查找一个对象（14节点），需要从list(0)开始，逐个遍历list中的对象，那么最大遍历次数是15；如果按照上图满二叉树存放，那么最大遍历次数是4（顺序是：根节点1→右子节点2→右子节点7→左子节点14。如何确定顺序，在后面的平衡二叉树中会讲解）。
由此可见，树结构用来查找，效率很高。而且用来新增、删除操作，也很简单，只要找到对应的节点，修改子节点或者父节点即可。
如下图的删除逻辑：如果要删除B节点，只要将A节点的左子节点指向D，将D节点的父节点指向A即可。
下面给出二叉树的生成逻辑。
MyNode节点对象：
/**
* 节点对象类
* @author 刘
* @date 2018年8月5日
*/
public class MyNode implements Serializable{
private static final long serialVersionUID = 1L;
public MyNode() {
}
public MyNode(int value) {
this.value = value;
}
private int value;//根据value值对节点进行排序
private MyNode leftNode;//左子节点
private MyNode rightNode;//右子节点
private MyNode parentNode;//父节点
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public MyNode getLeftNode() {
return leftNode;
}
public void setLeftNode(MyNode leftNode) {
this.leftNode = leftNode;
}
public MyNode getRightNode() {
return rightNode;
}
public void setRightNode(MyNode rightNode) {
this.rightNode = rightNode;
}
public MyNode getParentNode() {
return parentNode;
}
public void setParentNode(MyNode parentNode) {
this.parentNode = parentNode;
}
}
BTreeDemo.java
/**
* 二叉树demo
* @author 刘
* @date 2018年8月5日
*/
public class BTreeDemo {
public int maxDepth = 0;
public MyNode[] inits = {new MyNode(6),new MyNode(7),new MyNode(4),new MyNode(2),new MyNode(5),new MyNode(1)};
public static void main(String[] args) {
BTreeDemo demo = new BTreeDemo();
MyNode node = demo.sorting2Tree();
demo.printNode(node);
}
/**
* 获取一个二叉树的深度
* @author 刘
* @author 2018年8月5日
* @parameter
* @return
*/
public int getTreeDepth(MyNode node){
int depth = 0;//定义二叉树的深度
if(node == null){
return 0;
}
List<MyNode> list = new ArrayList<MyNode>();
List<MyNode> tmpList = new ArrayList<MyNode>();
list.add(node);
//如果第L层有节点，则depth++，继续获取L+1层的所有子节点
while(true){
if(list == null || list.size() <= 0){
break;
}
depth++;
for(int j = 0; j < list.size(); j++){
if(list.get(j).getLeftNode() != null){
tmpList.add(list.get(j).getLeftNode());
}
if(list.get(j).getRightNode() != null){
tmpList.add(list.get(j).getRightNode());
}
}
list.clear();
list.addAll(tmpList);
tmpList.clear();
}
return depth;
}
/**
* 获取二叉树某一层有效节点数
* @param node 二叉树
* @param level 第几层
* @return List<MyNode>
*/
public List<MyNode> getLevelNodeList(MyNode node, int level){
List<MyNode> list = new ArrayList<MyNode>();
if(level <= 0 || node == null){
return list;
}
list.add(node);
List<MyNode> tmpList = new ArrayList<MyNode>();
//因为层数是从1开始计算，所以这里需要将level-1。
for(int i = 0; i < level - 1; i++){
for(int j = 0; j < list.size(); j++){
if(list.get(j).getLeftNode() != null){
tmpList.add(list.get(j).getLeftNode());
}
if(list.get(j).getRightNode() != null){
tmpList.add(list.get(j).getRightNode());
}
}
list.clear();
list.addAll(tmpList);
tmpList.clear();
}
return list;
}
/**
* 将目标二叉树结构以value值的形式打印出来，不存在节点用#代替，打印的结果放到txt文件，然后改成csv，会看到二叉树的结构，如下
* @param node 目标二叉树
* ,,,,,,,6,,,,,,,
,,,4,,,,,,,,7,,,
,2,,,,5,,,,#,,,,#,
1,,3,,#,,#,,#,,#,,#,,#
*/
public void printNode(MyNode node){
StringBuffer sb = new StringBuffer();
int maxDepth = getTreeDepth(node);
if(maxDepth > 0){
for(int i = 0; i < maxDepth; i++){
//i层第一个节点的左边/最后一个节点的右边需要几个逗号分隔符
int maxJ = (int)Math.pow(2, maxDepth - i - 1) - 1;
for(int j = 0; j < maxJ; j++){
sb.append(",");
}
//i层的最大节点数
int levelCount = (int)Math.pow(2, i);
//i层相邻两个节点中间的间隔数
int gapCount = (int)(Math.pow(2, maxDepth - i) - 1);
for(int j = 0; j < levelCount; j++){
sb.append(getNodeValue(node, i + 1, j + 1, maxDepth));
if(levelCount > 1 && j < levelCount - 1){
for(int k = 0; k <= gapCount; k++){
sb.append(",");
}
}
}
for(int j = 0; j < maxJ; j++){
sb.append(",");
}
sb.append("\n");
}
System.out.println(sb.toString());
}
}
/**
* 将一组MyNode排序成二叉树（非平衡）
* @return
*/
public MyNode sorting2Tree(){
MyNode node = inits[0];
for(int i = 1; i < inits.length; i++){
interateCreateNode(node,inits[i]);
}
return node;
}
/**
* 递归方法生成有序二叉树（非平衡）
* @param node 节点
* @param newNode 新节点
*/
public void interateCreateNode(MyNode node, MyNode newNode){
/**
* 如果新节点的value<=原节点的value值：
* ①：如果原节点的左子节点不为空，则用原节点的【左子节】点和【newNode】进行比较（递归调用本方法）
* ②：如果原节点的左子节点为空，则将newNode设置为原节点的左子节点
*/
if(newNode.getValue() <= node.getValue()){
if(node.getLeftNode() != null){
interateCreateNode(node.getLeftNode(), newNode);
}else{
newNode.setParentNode(node);
node.setLeftNode(newNode);
}
}else{
//原理同上
if(node.getRightNode() != null){
interateCreateNode(node.getRightNode(), newNode);
}else{
newNode.setParentNode(node);
node.setRightNode(newNode);
}
}
}
/**
* 根据层数和序号，获取二叉树对应节点的value值
* @param node 二叉树
* @param level 层数（根节点level=1）
* @param index 序号（从左到右，从1开始）
* @return 对应节点的value值，如果不存在该节点，则返回#
*/
public String getNodeValue(MyNode node, int level, int index, int maxDepth){
if(maxDepth == 0){
return "请先计算深度";
}
if(level > maxDepth){
return "超出最大层数！";
}
if(index < 1 || index > Math.pow(2, level - 1)){
return "超出序号范围！";
}
if(node == null){
return "树不能为空！";
}
return this.interateGetNodeValue(node, level, index);
}
/**
* 根据层数和序号，获取二叉树对应节点的value值
* @param node 二叉树
* @param level 层数（根节点level=1）
* @param index 序号（从左到右，从1开始）
* @return 对应节点的value值，如果不存在该节点，则返回#
*/
private String interateGetNodeValue(MyNode node, int level, int index){
//如果只有一层，则直接返回node的value值
if(level == 1){
return String.valueOf(node == null ? "#" : node.getValue());
}
//如果是取第二层的节点，则判断是否为空后，直接返回value值。
if(level == 2){
if(index == 1){
return String.valueOf(node.getLeftNode() == null ? "#" : node.getLeftNode().getValue());
}else{
return String.valueOf(node.getRightNode() == null ? "#" : node.getRightNode().getValue());
}
}
/**
* 当层数>=3时，需要迭代执行本方法，将层数执行到第二层，用level=2返回value值
* ①：先判断目标节点在二叉树的左边还是右边（以根节点位置为竖轴，判断目标节点在竖轴的左边还是右边）
* ②：如果在左边，则将【根节点的左子节点，level-1,newIndex】座位参数，调用本方法。
*/
//目标层的最大节点数
int levelCount = (int)(Math.pow(2, level - 1));
//level-1后，新的序号（从左到右，从1开始）
int newIndex = 0;
//level-1后，新的根节点
MyNode newNode = null;
if(index > levelCount / 2){
newIndex = index - levelCount / 2;
newNode = node.getRightNode();
}else{
newIndex = index;
newNode = node.getLeftNode();
}
if(newNode == null){
return "#";
}
return interateGetNodeValue(newNode, level - 1, newIndex);
}
}
节点添加的步骤如下图：
