二叉树算法的java实现
package Alg;
public class BSTree {
private BSTreeNode root = null; //树根节点
private int count = 0; //树的节点数
public int getCount() {
return count;
}
public enum MatchType {E, GE, LE};
/**
* 根据值进行搜索
* @param val 匹配值
* @param matchType 匹配方式 E为严格相等匹配，GE为大于等于匹配，LE为小于等于匹配
* @return 匹配模式为E时，如果没有找到匹配项，返回null，否则返回匹配到的节点
* 匹配模式为GE时，如果匹配到数据，返回匹配到的数据，否则返回大于该数据的最小节点
* 匹配模式为LE时，如果匹配到数据，返回匹配到的数据，否则返回小于该数据的最大节点
*/
public BSTreeNode search(int val, MatchType matchType) {
BSTreeNode n = search(val);
if (n == null)
return null;
if (n.getValue() == val)
return n;
switch (matchType) {
case LE:
if (n.getValue() < val)
return n;
return getLittleSmaller(n);
case GE:
if (n.getValue() > val)
return n;
return getLittleBigger(n);
default:
}
return null;
}
private BSTreeNode search(int val) {
if (root == null)
return null;
return search(root, val);
}
/**
* 获取距离该值最近的节点
* @param n
* @param val
* @return
*/
private BSTreeNode search(BSTreeNode n, int val) {
int v = n.getValue();
if (v == val)
return n;
else if (v > val) {
if (n.getLeftChild() == null)
return n;
return search(n.getLeftChild(), val);
}
if (n.getRightChild() == null)
return n;
return search(n.getRightChild(), val);
}
/**
* 进行插入操作
* @param val
*/
public void insert(int val) {
if (root == null) {
root = BSTreeNode.createNode(val);
count++;
return;
}
BSTreeNode x = search(val);
if (x.getValue() == val)
return;
BSTreeNode n = BSTreeNode.createNode(val);
count++;
if (x.getValue() < val)
x.setRightChild(n);
else
x.setLeftChild(n);
n.setParent(x);
}
/**
* 删除值
* @param val
*/
public void delete(int val) {
if (root == null)
return;
BSTreeNode x = search(val);
if (x.getValue() != val)
return;
count--;
//删除仅剩的一个节点
if (count == 0) {
root = null;
return;
}
//当为叶子节点时从父节点将该节点的连接删除
if (x.isLeaf()) {
BSTreeNode p = x.getParent();
if (p.getLeftChild() == x)
p.setLeftChild(null);
else
p.setRightChild(null);
}
BSTreeNode lc = x.getLeftChild();
BSTreeNode rc = x.getRightChild();
//如果具有两个非空子树，或者从左子树中取得最大的节点代替当前节点
//或者从右子树取得最小节点代替当前节点
//然后删除代替的节点
if (lc != null && rc != null) {
BSTreeNode lrm = getRightMostNode(lc);
BSTreeNode rlm = getLeftMostNode(rc);
//如果是叶节点则可以简单替换节点进行处理，否则要替换后进行再次替换
if (lrm.isLeaf()) {
x.setValue(lrm.getValue());
BSTreeNode rp = lrm.getParent();
rp.setRightChild(null);
return ;
}
else if (rlm.isLeaf()) {
x.setValue(rlm.getValue());;
BSTreeNode lp = rlm.getParent();
lp.setLeftChild(null);
return ;
}
else {
//调换两个节点，并将删除转换为只有一个子树的情况
x.setValue(lrm.getValue());
x = lrm;
}
}
//如果只有一个子树（左子树或右子树），则用子树中的根代替当前节点
BSTreeNode p = x.getParent();
lc = x.getLeftChild();
rc = x.getRightChild();
if (lc != null) {
if (p.getLeftChild() == x)
p.setLeftChild(lc);
else
p.setRightChild(lc);
return ;
}
if (rc != null) {
if (p.getLeftChild() == x)
p.setLeftChild(rc);
else
p.setRightChild(rc);
}
}
/**
* 以升序方式打印树中节点，实际就是中根的树的访问次序
*/
public void printInAscOrd() {
if (root == null)
System.out.println("没有数据");
printInOrder(root);
}
/**
* 将二叉树转换为升序排列的数组
* @return 返回升序排序后的数组
*/
public BSTreeNode[] getAscOrderArray() {
BSTreeNode[] ary = new BSTreeNode[count];
int pos = fillArrayInOrd(ary, 0, root);
if (pos != count)
System.out.println("构造数组出错");
return ary;
}
private int fillArrayInOrd(BSTreeNode[] ary, int pos, BSTreeNode root) {
int npos = pos;
if (root.getLeftChild() != null) {
npos = fillArrayInOrd(ary, npos, root.getLeftChild());
}
ary[npos] = root;
npos++;
if (root.getRightChild() != null) {
npos = fillArrayInOrd(ary, npos, root.getRightChild());
}
return npos;
}
/**
* 获取大于当前节点的最小节点
* @param x
* @return 如果没有大于该节点的节点，则返回null
*/
private BSTreeNode getLittleBigger(BSTreeNode x) {
BSTreeNode rc = x.getRightChild();
if (rc != null) {
return getLeftMostNode(rc);
}
else {
//回溯祖先节点，取得第一个令该节点为左子树节点的祖先节点
BSTreeNode p = x.getParent();
BSTreeNode s = x;
while (p != null) {
if (p.getLeftChild() == s)
break;
s = p;
p = p.getParent();
}
return p;
}
}
private BSTreeNode getLittleSmaller(BSTreeNode x) {
BSTreeNode lc = x.getLeftChild();
if (lc != null) {
return getRightMostNode(lc);
}
else {
//回溯祖先节点，取得第一个令该节点为左子树节点的祖先节点
BSTreeNode p = x.getParent();
BSTreeNode s = x;
while (p != null) {
if (p.getRightChild() == s)
break;
s = p;
p = p.getParent();
}
if (p != null)
return p;
}
return null;
}
private BSTreeNode getLeftMostNode(BSTreeNode x) {
BSTreeNode l = x;
while (l.getLeftChild() != null) {
l = l.getLeftChild();
}
return l;
}
private BSTreeNode getRightMostNode(BSTreeNode x) {
BSTreeNode r = x;
while (r.getRightChild() != null) {
r = r.getRightChild();
}
return r;
}
private void printInOrder(BSTreeNode n) {
if (n.getLeftChild() != null)
printInOrder(n.getLeftChild());
printNode(n);
if (n.getRightChild() != null)
printInOrder(n.getRightChild());
}
private void printNode(BSTreeNode n) {
System.out.print("[" + n.getValue() + "]");
}
private void checkTreeValidation() throws Exception {
BSTreeNode[] ary = this.getAscOrderArray();
for (int i = 0; i < ary.length - 1; i++) {
if (ary[i].getValue() > ary[i + 1].getValue()) {
throw new Exception("二叉树出现错误");
}
}
}
public static BSTree buildRandomTree1() {
BSTree tree = new BSTree();
try {
tree.insert(8569);
tree.insert(7556);
tree.insert(3421);
tree.insert(5665);
tree.insert(5169);
tree.insert(9189);
tree.insert(5656);
tree.insert(6691);
tree.insert(6932);
tree.insert(3511);
tree.insert(4269);
tree.insert(3556);
tree.checkTreeValidation();
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static BSTree buildRandomTree2() {
BSTree tree = new BSTree();
try {
tree.insert(53);
tree.insert(12);
tree.insert(27);
tree.insert(99);
tree.insert(46);
tree.insert(5);
tree.insert(38);
tree.checkTreeValidation();
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase1() {
BSTree tree = buildRandomTree1();
if (tree == null)
System.out.println("构造二叉树出错");
tree.printInAscOrd();
}
public static void testInsertCase2() {
BSTree tree = buildRandomTree2();
if (tree == null)
System.out.println("构造二叉树出错");
tree.printInAscOrd();
}
public static void testGetArray() {
BSTree tree = buildRandomTree2();
if (tree == null)
System.out.println("构造二叉树出错");
BSTreeNode[] ary = tree.getAscOrderArray();
for (int i = 0; i < ary.length; i++) {
System.out.print("[");
System.out.print(ary[i].getValue());
System.out.print("]");
}
}
public static void testDeleteCase1() {
BSTree tree = buildRandomTree2();
if (tree == null)
System.out.println("构造二叉树出错");
tree.printInAscOrd();
BSTreeNode[] ary = tree.getAscOrderArray();
System.out.println();
System.out.println("删除" + ary[3].getValue());
tree.delete(ary[3].getValue());
tree.printInAscOrd();
System.out.println();
System.out.println("删除" + ary[5].getValue());
tree.delete(ary[5].getValue());
tree.printInAscOrd();
}
public static void testGetLittleBigger(){
BSTree tree = buildRandomTree2();
if (tree == null)
System.out.println("构造二叉树出错");
tree.printInAscOrd();
System.out.println("");
BSTreeNode[] ary = tree.getAscOrderArray();
for (int i = 0; i < ary.length - 1; i++) {
BSTreeNode n = ary[i];
BSTreeNode b = tree.getLittleBigger(n);
System.out.println("当前数值" + n.getValue() +"." + "较大数值为" + b.getValue());
if (b.getValue() != ary[i + 1].getValue())
System.out.println("出现错误");
else
System.out.println("正确");
}
}
public static void testGetLittleSmaller() {
BSTree tree = buildRandomTree2();
if (tree == null)
System.out.println("构造二叉树出错");
tree.printInAscOrd();
System.out.println("");
BSTreeNode[] ary = tree.getAscOrderArray();
for (int i = ary.length - 1; i > 0; i--) {
BSTreeNode n = ary[i];
BSTreeNode s = tree.getLittleSmaller(n);
System.out.println("当前数值" + n.getValue() +"." + "较小数值为" + s.getValue());
if (s.getValue() != ary[i - 1].getValue())
System.out.println("出现错误");
else
System.out.println("正确");
}
}
}
package Alg;
public class BSTreeNode {
private BSTreeNode leftChild = null;
private BSTreeNode rightChild = null;
private BSTreeNode parent = null;
private int value = Integer.MIN_VALUE;
public static BSTreeNode createNode(int val) {
return new BSTreeNode(val);
}
private BSTreeNode(int val) {
leftChild = null;
rightChild = null;
parent = null;
value = val;
}
public boolean isLeaf() {
if (getLeftChild() == null && getRightChild() == null)
return true;
return false;
}
public boolean isRoot() {
if (getParent() == null)
return true;
return false;
}
public BSTreeNode getLeftChild() {
return leftChild;
}
public void setLeftChild(BSTreeNode leftChild) {
this.leftChild = leftChild;
}
public BSTreeNode getRightChild() {
return rightChild;
}
public void setRightChild(BSTreeNode rightChild) {
this.rightChild = rightChild;
}
public BSTreeNode getParent() {
return parent;
}
public void setParent(BSTreeNode parent) {
this.parent = parent;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
写在纸上的内容
