二叉排序树的增删改操作

二叉排序树又称二叉查找树。

- 若根节点的左子树非空，则左子树上所有节点的关键字值均小于等于根节点的关键字。

- 若根节点的右子树非空，则右子树上所有节点的关键字均大于等于根节点的关键字。

- 根节点的左右子树也分别为二叉排序树。

-- 二叉排序树的中根遍历序列为按关键字升序排列的。

节点类

package com.ITree.Demo;

public class BinaryOrderTreeNode
{
String name;
String action;
String grade;

BinaryOrderTreeNode left, right;

public BinaryOrderTreeNode(String name, String action, String grade)
{
this.name = name;
this.action = action;
this.grade = grade;
}

}

树

package com.ITree.Demo;

public class BinaryOrderTree
{
/**
* 根节点
*/
BinaryOrderTreeNode root;

/**
* 查找节点
*
* @param name
* @param isPre
* @return
*/
private BinaryOrderTreeNode search(String name, boolean isPre)
{
BinaryOrderTreeNode res = null;
BinaryOrderTreeNode preNode = null;
BinaryOrderTreeNode node = root;

while (node != null && res == null)
{
int greater = name.compareTo(node.name);
//            System.out.println("search:" + node.name);
if (greater == 0)
{
res = node;
}
else
{
preNode = node;
if (greater < 0)
node = node.left;
else
node = node.right;
}
}
if (isPre && res != null)
{
return preNode == null ? res : preNode;
}
return res;
}

/**
* 添加节点
*
* @param name
*/
public void addNode(String name)
{
//        System.out.println("addNode:" + name);
root = insert(name, root);
}

/**
* 递归添加节点
*
* @param name
* @param node
* @return
*/
private BinaryOrderTreeNode insert(String name, BinaryOrderTreeNode node)
{
if (node == null)
{
node = new BinaryOrderTreeNode(name, "", "");
}
else
{
int greater = name.compareTo(node.name);
if (greater < 0)
{
node.left = insert(name, node.left);
}
else if (greater > 0)
{
node.right = insert(name, node.right);
}
}
return node;
}

public void removeNode(String name)
{
BinaryOrderTreeNode preNode = search(name, true);
//        System.out.println("removeNode=" + name + " : " + preNode);
if (preNode != null)
{
//            System.out.println("removeNode=" + name + " : " + preNode.name);
if (name.equals(preNode.name))
{
// 删除节点为根节点
if (preNode.left != null)
{
root = preNode.left;
sortNode(preNode.right);
}
else
{
root = preNode.right;
}
preNode = null;
}
else
{
BinaryOrderTreeNode node = null;
if (preNode.left != null && name.equals(preNode.left.name))
{
// 删除节点为左节点
node = preNode.left;
// 删除
preNode.left = null;
}
else
{
// 删除节点为右节点
node = preNode.right;
preNode.right = null;
}

if (node != null)
{
sortNode(node.left);
sortNode(node.right);
}
}
}
}

private void sortNode(BinaryOrderTreeNode data)
{
if (data != null)
{
//            System.out.println("sortNode=" + data.name);
getNode(data);
}
}

private BinaryOrderTreeNode getNode(BinaryOrderTreeNode node)
{
if (node != null)
{
getNode(node.left);
//            System.out.println("insert : " + node.name);
insert(node.name, root);
getNode(node.right);
}
return node;
}

public void update(BinaryOrderTreeNode data)
{
BinaryOrderTreeNode node = search(data.name, false);
//        System.out.println("update=" + data.name + " : " + node);
if (node != null)
{
//            System.out.println("update=" + data.name + " : " + node.name);
node.name = data.name;
node.action = data.action;
node.grade = data.grade;
}
else
{
addNode(data.name);
}
}

/**
* 输出
*/
public void outPrint()
{
System.out.println("print start...");
inOrder(root);
System.out.println("\nprint end...\n");
}

/**
* 中序遍历
*
* @param node
* @return
*/
private BinaryOrderTreeNode inOrder(BinaryOrderTreeNode node)
{
if (node != null)
{
inOrder(node.left);
System.out.print("  (" + node.name + "," + node.action + ","
+ node.grade + ")");
inOrder(node.right);
}
return node;
}

}

数据测试

package com.ITree.Demo;

public class TreeManager
{

/**
* 1-add 2-del 3-update grade 123
*
* @param args
*/
public static void main(String[] args)
{
BinaryOrderTree tree = new BinaryOrderTree();
/**
* 数据测试
*/
String[][] data = new String[][] { {"2", "2", "2" }, {"4", "0", "2" },
{"3", "2", "3" }, {"6", "0", "1" }, {"8", "0", "3" },
{"1", "0", "2" }, {"5", "0", "1" }, {"0", "2", "1" },
{"7", "0", "3" }, {"3", "3", "3" }, {"0", "1", "3" } };
int len = data.length;
for (int i = 0; i < len - 2; i++)
{
tree.addNode(data[i][0]);
tree.outPrint();
}

for (int i = 0; i < len; i++)
{
String action = data[i][1];
if (action == "1")
{
tree.addNode(data[i][0]);
tree.outPrint();
}
else if (action == "2")
{
tree.removeNode(data[i][0]);
tree.outPrint();
}
else if (action == "3")
{
tree.update(new BinaryOrderTreeNode(data[i][0], data[i][1],
data[i][2]));
tree.outPrint();
}
}

}

}