java实现平衡二叉树的建立

有关平衡二叉树的概念以及平衡二叉树的旋转操作：平衡二叉树

class Node {
int data;//数据
int BF;//平衡因子
Node leftChild;//左娃娃
Node rightChild;//右娃娃
public Node(int data) {
super();
this.data = data;
}

}

public class 平衡二叉树的建立 {
private static   Node head;//表示头节点
private static Node[] path = new Node[32];//记录访问路径上的节点
private static int  p ;//表示当前访问到的节点在path中的索引

public static boolean addNode(int value){
if(head == null){
head = new Node(value);
//不要忘了平衡因子的修改
head.BF = 0;//刚开始head的平衡因子为0
return true;
}

p = 0;
Node prev = null;//上一次访问到的节点
Node current = head;//当前访问的节点
//寻找插入位置
while(current != null){

path[p++] = current;
if(current.data == value){
return false;//若value与当前数据相同，则返回false,无需插入
}
prev = current;
//当前值小于左孩子，继续访问左孩子
//否则访问右孩子
current = (value < prev.data) ? prev.leftChild : prev.rightChild;

}
current = new Node(value);
//不要忘了平衡因子的修改current.BF = 0
current.BF = 0;
if(value < prev.data){
prev.leftChild = current;
}else{
prev.rightChild = current;
}
path[p] = current;//将当前节点插入到path中的最后
int  bf = 0;
//修改插入节点至根节点路径上的各个节点的平衡因子

while( p > 0){
bf = (value < path[p-1].data) ? 1 : -1;
path[--p].BF  += bf;
bf = path[p].BF;//取出当前的平衡因子
//若当前平衡因子为0，则表示该子树已平衡，无需递归了
//若为2或者-2，表示要对改子树进行旋转操作
if( bf == 0){
return true;

}

else if(bf == 2 || bf == -2){
旋转(bf);
return true;
}
}

return true;
}
//对树的旋转操作
private static boolean  旋转(int bf) {
Node root  = path[p];
Node newRoot = null;
boolean tallChange = true;

if(bf == 2){
if(root.leftChild.BF == 1){//进行LL旋转操作()
newRoot = LL(root);
}else if(root.leftChild.BF == -1){//进行LR旋转操作
newRoot = LR(root);
}
}else if(bf == -2){
if(root.rightChild.BF == -1){//进行RR旋转操作
newRoot  = RR(root);
}else if(root.rightChild.BF == 1){
newRoot = RL(root);
}
}
//更改新的子树
if(p > 0){
if(root.data < path[p-1].data){
path[p-1].leftChild = newRoot;
}else{
path[p-1].rightChild = newRoot;
}
}else{
head = newRoot;
}
return tallChange;

}
private static Node RL(Node root) {
Node rootNext = root.rightChild;
Node newRoot = rootNext.leftChild;
root.rightChild = newRoot.leftChild;
rootNext.leftChild = newRoot.rightChild;
newRoot.leftChild = root;
newRoot.rightChild = rootNext;

switch (newRoot.BF) {

case 1:
root.BF = 0;
rootNext.BF = -1;

break;
case -1:
root.BF = 1;
rootNext.BF=0;
break;

}

return newRoot;
}
private static Node RR(Node root) {//RR型旋转操作
Node  rootNext = root.rightChild;
root.rightChild = rootNext.leftChild;
rootNext.leftChild = root;
//不要忘了平衡因子的修改
if(rootNext.BF == -1){
rootNext.BF = 0;
root.BF = 0;
}
return rootNext;
}
private static Node LR(Node root) {
Node rootNext = root.leftChild;
Node newRoot = rootNext.rightChild;
root.leftChild = newRoot.rightChild;
rootNext.rightChild = newRoot.leftChild;
newRoot.leftChild = rootNext;
newRoot.rightChild = root;
//改变平衡因子
switch (newRoot.BF) {

case 1:
root.BF = -1;
rootNext.BF = 0;
break;
case -1:
root.BF = 0;
rootNext.BF = 1;
break;

}
newRoot.BF = 0;
return newRoot;

}
private static Node LL(Node root) {//LL型旋转操作
Node rootNext = root.leftChild;
root.leftChild = rootNext.rightChild;
rootNext.rightChild = root;

//旋转后不要忘了平衡因子的修改
if(rootNext.BF == 1){
rootNext.BF = 0;
root.BF = 0;
}
return rootNext;
}

public static void main(String[] args) {
addNode(1);
addNode(2);
addNode(3);

addNode(4);
addNode(5);
addNode(6);
addNode(7);

print(head);
}

private static void print(Node root) {//按照先序遍历  肯定是顺序输出，即为1,2,3,4,5,6,7

if(root.leftChild !=null){
print(root.leftChild);
}
System.out.println(root.data);
if(root.rightChild!=null){
print(root.rightChild);
}
}

}