树——平衡二叉树插入和查找的JAVA实现(2):增加删除方法

package com.tomsnail.data.tree;
/**
* AVL二叉平衡树
* @author tomsnail
* @date 2015年3月30日 下午4:35:50
*/
public class AVLTree {

/**
* 根节点
* @author tomsnail
* @date 2015年3月30日 下午4:36:54
*/
private AVLNode rootNode;

private String bulidType = "";

/**
* 增加一个节点
* @author tomsnail
* @date 2015年3月30日 下午4:36:08
*/
public void add(int value){
AVLNode subNode = null;
if(rootNode==null){
subNode  = new AVLNode(value);
rootNode = subNode;
}else{
subNode = addNode(rootNode,value);
}
reBuild(subNode);

}

private AVLNode addNode(AVLNode node,int value){
AVLNode subNode = null;
if(node.getValue()>value){
if(node.getLeftNode()==null){
subNode = new AVLNode(value);
node.setLeftNode(subNode);
}else{
subNode = addNode(node.getLeftNode(), value);
}
}
if(node.getValue()<value){
if(node.getRightNode()==null){
subNode = new AVLNode(value);
node.setRightNode(subNode);
}else{
subNode = addNode(node.getRightNode(),value);
}
}
return subNode;
}
/**
* 重平衡树
* @author tomsnail
* @date 2015年3月30日 下午5:42:00
*/
private void reBuild(AVLNode node){
if(node!=null){
AVLNode tempRootNode = findTempRootNode(node);
if(tempRootNode!=null){
if(bulidType.equals("ll")){
Lrotate(node,tempRootNode);
}else if(bulidType.equals("rr")){
Rrotate(node,tempRootNode);
}else if(bulidType.equals("lr")){
Rrotate(node,tempRootNode.getLeftNode());
Lrotate(node,tempRootNode);
}else if(bulidType.equals("rl")){
Lrotate(node,tempRootNode.getRightNode());
Rrotate(node,tempRootNode);
}
reBuild(tempRootNode);
}
}
}
/**
* 右旋
* @author tomsnail
* @date 2015年3月30日 下午9:23:28
*/
private void Rrotate(AVLNode node,AVLNode tempRootNode){
AVLNode rotateNode = tempRootNode.getRightNode();//旋转节点
AVLNode rootNode = tempRootNode.getRootNode();//主根节点
String type = "";
if(rootNode!=null){
if(rootNode.getLeftNode()==tempRootNode){
type="l";
}else{
type="r";
}
}
AVLNode adjustNode = rotateNode.getLeftNode();//调整节点
rotateNode.setLeftNode(tempRootNode);
tempRootNode.setRightNode(null);
if(adjustNode!=null){
tempRootNode.setRightNode(adjustNode);
}
if(rootNode==null){
rotateNode.setRootNode(null);
this.rootNode = rotateNode;
}
if(type.equals("r")){
rootNode.setRightNode(rotateNode);
}else if(type.equals("l")){
rootNode.setLeftNode(rotateNode);
}
}
/**
* 左旋
* @author tomsnail
* @date 2015年3月30日 下午9:23:28
*/
private void Lrotate(AVLNode node,AVLNode tempRootNode){
AVLNode rotateNode = tempRootNode.getLeftNode();//旋转节点
AVLNode rootNode = tempRootNode.getRootNode();//主根节点
String type = "";
if(rootNode!=null){//子树类型
if(rootNode.getLeftNode()==tempRootNode){
type="l";
}else{
type="r";
}
}
AVLNode adjustNode = rotateNode.getRightNode();//调整节点
rotateNode.setRightNode(tempRootNode);
tempRootNode.setLeftNode(null);
if(adjustNode!=null){
tempRootNode.setLeftNode(adjustNode);
}
if(rootNode==null){
rotateNode.setRootNode(null);
this.rootNode = rotateNode;
}
if(type.equals("r")){
rootNode.setRightNode(rotateNode);
}else if(type.equals("l")){
rootNode.setLeftNode(rotateNode);
}
}

/**
* 查找最小不平衡的根节点
* @author tomsnail
* @date 2015年3月30日 下午5:40:55
*/
private AVLNode findTempRootNode(AVLNode node){
AVLNode noB = getNoBalance(node);
if(noB==null){
return null;
}
if(isTypeLL(noB)){
bulidType = "ll";
}else if(isTypeRR(noB)){
bulidType = "rr";
}else if(isTypeLR(noB)){
bulidType = "lr";
}else if(isTypeRL(noB)){
bulidType = "rl";
}
return noB;
}
//左左类型
private boolean isTypeLL(AVLNode noB){
try {
if(noB.getRightNode()==null&&noB.getLeftNode().getRightNode()==null&&!noB.getLeftNode().getLeftNode().hasSubNode()){
return true;
}
if(noB.getRightNode()!=null&&noB.getLeftNode().getRightNode()!=null&&noB.getLeftNode().getLeftNode().hasSubNode()){
return true;
}
} catch (Exception e) {
}
return false;
}
//右右类型
private boolean isTypeRR(AVLNode noB){
try {
if(noB.getLeftNode()==null&&noB.getRightNode().getLeftNode()==null&&!noB.getRightNode().getRightNode().hasSubNode()){
return true;
}
if(noB.getLeftNode()!=null&&noB.getRightNode().getLeftNode()!=null&&noB.getRightNode().getRightNode().hasSubNode()){
return true;
}
} catch (Exception e) {
}
return false;
}
//左右类型
private boolean isTypeLR(AVLNode noB){
try {
if(noB.getRightNode()==null&&noB.getLeftNode().getLeftNode()==null&&!noB.getLeftNode().getRightNode().hasSubNode()){
return true;
}
if(noB.getRightNode()!=null&&noB.getLeftNode().getLeftNode()!=null&&noB.getLeftNode().getRightNode().hasSubNode()){
return true;
}
} catch (Exception e) {
}
return false;
}
//右左类型
private boolean isTypeRL(AVLNode noB){
try {
if(noB.getLeftNode()==null&&noB.getRightNode().getRightNode()==null&&!noB.getRightNode().getLeftNode().hasSubNode()){
return true;
}
if(noB.getLeftNode()!=null&&noB.getRightNode().getRightNode()!=null&&noB.getRightNode().getLeftNode().hasSubNode()){
return true;
}
} catch (Exception e) {
}
return false;
}

//获取不平衡的根节点
private AVLNode getNoBalance(AVLNode node){
if(node.getRootNode()==null){
return null;
}else{
if(!isBalance(node.getRootNode())){
return node.getRootNode();
}else{
return getNoBalance(node.getRootNode());
}
}
}

/**
* 删除一个节点
* @author tomsnail
* @date 2015年3月30日 下午4:36:20
*/
public void delete(int value){
AVLNode wantDeleteNode = find(value);
if(wantDeleteNode==null){
return;
}else{
if(wantDeleteNode.getLeftNode()==null&&wantDeleteNode.getRightNode()==null){//删除节点没有左右子树
AVLNode rootNode = wantDeleteNode.getRootNode();
if(rootNode!=null){
if(rootNode.getLeftNode()==wantDeleteNode){
rootNode.setLeftNode(null);
}else{
rootNode.setRightNode(null);
}
reBuild(rootNode);
}
}else if(wantDeleteNode.getRightNode()==null){//删除节点只有左子树
AVLNode rootNode = wantDeleteNode.getRootNode();
if(rootNode!=null){
if(rootNode.getLeftNode()==wantDeleteNode){
rootNode.setLeftNode(wantDeleteNode.getLeftNode());
}else{
rootNode.setRightNode(wantDeleteNode.getLeftNode());
}
wantDeleteNode.setLeftNode(null);
reBuild(rootNode);
}
}else if(wantDeleteNode.getLeftNode()==null){//删除节点只有右子树
AVLNode rootNode = wantDeleteNode.getRootNode();
if(rootNode!=null){
if(rootNode.getRightNode()==wantDeleteNode){
rootNode.setLeftNode(wantDeleteNode.getRightNode());
}else{
rootNode.setRightNode(wantDeleteNode.getRightNode());
}
wantDeleteNode.setRightNode(null);
reBuild(rootNode);
}
}else {//删除节点有左右子树
AVLNode maxNode = getLeftMaxValueNode(wantDeleteNode.getLeftNode());//找到节点左子树最大值的节点
AVLNode rootMaxNode = maxNode.getRootNode();//获得该节点的父节点
if(maxNode.getLeftNode()!=null){//如果最大值节点有左子树，则将最大值节点的父节点的右子树设为它
rootMaxNode.setRightNode(maxNode.getLeftNode());
maxNode.setLeftNode(null);
}else{//否则置空
rootMaxNode.setRightNode(null);
}
wantDeleteNode.setValue(maxNode.getValue());//把要删除节点的值用最大值节点的值替换
maxNode=null;//引用置空
reBuild(rootMaxNode);
}
}
}
//得到左子树最大值节点
private AVLNode getLeftMaxValueNode(AVLNode node){
if(node!=null&&node.getRightNode()!=null){
return getLeftMaxValueNode(node.getRightNode());
}else{
return node;
}
}

/**
* 查找一个节点
* @author tomsnail
* @date 2015年3月30日 下午4:36:35
*/
public AVLNode find(int value){
return findWith2(rootNode,value);
}
private AVLNode findWith2(AVLNode node,int value){
if(node==null){
return null;
}
System.out.println(node.getValue());
if(node.getValue()>value){
return findWith2(node.getLeftNode(),value);
}else if(node.getValue()<value){
return findWith2(node.getRightNode(),value);
}else{
return node;
}
}

/**
* 中序遍历
* @author tomsnail
* @date 2015年3月31日 下午6:23:05
*/
public void midScan(AVLNode node){
if(node==null){
return;
}
midScan(node.getLeftNode());
System.out.println(node.getValue());
midScan(node.getRightNode());
}

public AVLNode getRootNode() {
return rootNode;
}

public static void main(String[] args) {
int[] is = new int[]{10,11,23,3,5,44,32,4,6,18,19,7,8,70,50,60,40,55,65,53,80};//10,11,23,3,5,44,32,4,6,18,19,7,8,70,50,60,40,55,65,53,80
AVLTree tree = new AVLTree();
for(int i=0;i<is.length;i++){
tree.add(is[i]);
}
System.out.println(tree.getRootNode().getValue());
System.out.println("----------------------------");
tree.midScan(tree.getRootNode());
tree.delete(4);
System.out.println(isBalance(tree.getRootNode()));
System.out.println();
//tree.find(40);
}

public static int depth(AVLNode node){
if(node==null){
return 0;
}else{
int ld = depth(node.getLeftNode());
int rd = depth(node.getRightNode());
return 1 + (ld >rd ? ld : rd);
}
}

public static boolean isBalance(AVLNode node){
if (node==null)
return true;
int dis = depth(node.getLeftNode()) - depth(node.getRightNode());
if (dis>1 || dis<-1 )
return false;
else
return isBalance(node.getLeftNode()) && isBalance(node.getRightNode());
}
}
class AVLNode{
private int value;
private AVLNode leftNode;
private AVLNode rightNode;
private AVLNode rootNode;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public AVLNode getLeftNode() {
return leftNode;
}
public void setLeftNode(AVLNode leftNode) {
this.leftNode = leftNode;
if(leftNode!=null){
leftNode.setRootNode(this);
}
}
public AVLNode getRightNode() {
return rightNode;
}
public void setRightNode(AVLNode rightNode) {
this.rightNode = rightNode;
if(rightNode!=null){
rightNode.setRootNode(this);
}
}

public AVLNode getRootNode() {
return rootNode;
}
public void setRootNode(AVLNode rootNode) {
this.rootNode = rootNode;
}

public boolean hasSubNode(){
if(this.leftNode!=null||this.rightNode!=null){
return true;
}else{
return false;
}
}

public AVLNode(){
}
public AVLNode(int value){
this.value = value;
}
}