1，实例变量，构造器，数组扩展
private Object[] contents;
private int count;
public ArrayBinarySearchTree(Object root)
{
// Object[] contents = new Object[10]; 悲剧啊！！！！局部变量覆盖了类成员变量
contents = new Object[ 10 ];
contents[ 0 ] = root;
count = 1 ;
}
public void expand()
{
// Object[] larger = new Object[size()*3];
Object[] larger = new Object[contents.length * 3 ];
for ( int i = 0 ;i < contents.length;i ++ )
larger[i] = contents[i];
contents = larger;
}
跟二叉树的数组实现差不多
2，三种迭代器方法，删除左右子树的方法跟二叉树的数组实现一样，参见清单
3，重新定义的public int find(Comparable target)方法，相对于链式实现，在数组实现中我觉得查找一个元素返回它的下标更贴切
// 改了一下，返回找到的元素的下标，觉得这样对数组来说更有意义把
public int find(Comparable target) {
if (isEmpty())
{
System.out.println( " 树为空！ " );
return - 1 ;
}
int index = 0 ;
while (index < contents.length && contents[index] != null )
{
if (contents[index].equals(target))
return index;
else if (target.compareTo(contents[index]) < 0 )
index = 2 * index + 1 ;
else index = 2 * index + 2 ;
}
return - 1 ;
}
3，二叉排序树里的重要方法
1）插入节点
数组实现插入其实跟链式思想还是一样，往下找插入节点就是往下找插入的下标，下标的关系已经在前面说过，要注意的是数组容量可能不够，需要扩展容量
public void addElement(Comparable element) {
int index = 0 ;
if (size() == 0 )
{
contents[index] = element;
count ++ ;
return ;
}
while (index < contents.length)
{
if (element.compareTo(contents[index]) < 0 )
{
int lindex = 2 * index + 1 ;
if (lindex >= contents.length)
expand();
if (contents[lindex] == null )
contents[lindex] = element;
else index = lindex;
}
else
{
int rindex = 2 * index + 2 ;
if (rindex >= contents.length)
expand();
if (contents[rindex] == null )
contents[rindex] = element;
else index = rindex;
}
}
count ++ ;
}
2）删除节点
用数组来实现删除节点似乎不太合适（也许是我自己没有想到好的方法），当某个结点被删后，它的子树上的全部结点的下标都要调整，而且这个调整顺序还得从上网下调，否则下面的节点的可能覆盖上面的，没有想到什么好的办法，最后只有用了一个消耗最大的笨方法—将被删结点置为null后，前序遍历树（或者后序，不能中序），将前序序列依次重新插入建树。相当于删除节点后，把剩下结点取出来重新建树，实在不知道有什么简易的办法了：
public Comparable removeElement(Comparable element) {
Comparable result = null ;
int index = find(element); // 找到指定删除元素在数组中的下标
if (index != - 1 )
{
result = (Comparable) contents[index];
remove(index);
// count--;在remove里已经实现了
}
return result;
}
private void remove( int index){ // 删除指定下标处的元素,并得到删除后的树（调整位置）
Iterator it = PreInorder(); // 得到前序遍历的迭代器
for ( int i = 0 ;i < contents.length;i ++ ) // 将树清空
contents[i] = null ;
count = 0 ;
while (it.hasNext())
{
addElement((Comparable) it.next());
}
}
3）返回/删除 最大值
删除最大值还是调用上面的remove（int index）方法，先找到最大值的index即可。
返回最大值如下：
public Comparable findMax() {
int index = 0 ;
while (( 2 * index + 2 < contents.length) && (contents[ 2 * index + 2 ] != null ))
index = 2 * index + 2 ;
return (Comparable) contents[index];
}
4）清单及测试：
ArrayBinarySearchTree{
package
Tree;
import
java.util.Iterator;
import
Queue.LinkedQueue;
public
class
ArrayBinarySearchTree{
private
Object[] contents;
private
int
count;
public
ArrayBinarySearchTree(Object root)
{
//
Object[] contents = new Object[10]; 悲剧啊！！！！局部变量覆盖了类成员变量
contents
=
new
Object[
10
];
contents[
0
]
=
root;
count
=
1
;
}
public
void
expand()
{
//
Object[] larger = new Object[size()*3];
Object[] larger
=
new
Object[contents.length
*
3
];
for
(
int
i
=
0
;i
<
contents.length;i
++
)
larger[i]
=
contents[i];
contents
=
larger;
}
public
int
size() {
return
count;
}
public
boolean
isEmpty() {
return
(size()
==
0
);
}
public
Iterator iteratorInorder() {
LinkedQueue queue
=
new
LinkedQueue();
inorder(
0
,queue);
return
queue.iterator();
}
private
void
inorder(
int
index,LinkedQueue queue){
if
(index
<
contents.length
&&
contents[index]
!=
null
)
{
int
lindex
=
2
*
index
+
1
;
int
rindex
=
2
*
index
+
2
;
if
(lindex
<
contents.length
&&
contents[lindex]
!=
null
)
inorder(lindex,queue);
queue.enqueue(contents[index]);
if
(rindex
<
contents.length
&&
contents[rindex]
!=
null
)
inorder(rindex,queue);
}
}
public
Iterator PreInorder() {
LinkedQueue queue
=
new
LinkedQueue();
preorder(
0
,queue);
return
queue.iterator();
}
private
void
preorder(
int
index,LinkedQueue queue){
if
(index
<
contents.length
&&
contents[index]
!=
null
)
{
int
lindex
=
2
*
index
+
1
;
int
rindex
=
2
*
index
+
2
;
queue.enqueue(contents[index]);
if
(lindex
<
contents.length
&&
contents[lindex]
!=
null
)
preorder(lindex,queue);
if
(rindex
<
contents.length
&&
contents[rindex]
!=
null
)
preorder(rindex,queue);
}
}
public
Iterator PostInorder() {
LinkedQueue queue
=
new
LinkedQueue();
postorder(
0
,queue);
return
queue.iterator();
}
private
void
postorder(
int
index,LinkedQueue queue){
if
(index
<
contents.length
&&
contents[index]
!=
null
)
{
int
lindex
=
2
*
index
+
1
;
int
rindex
=
2
*
index
+
2
;
if
(lindex
<
contents.length
&&
contents[lindex]
!=
null
)
postorder(lindex,queue);
if
(rindex
<
contents.length
&&
contents[rindex]
!=
null
)
postorder(rindex,queue);
queue.enqueue(contents[index]);
}
}
//
改了一下，返回找到的元素的下标，觉得这样对数组来说更有意义把
public
int
find(Comparable target) {
if
(isEmpty())
{
System.out.println(
"
树为空！
"
);
return
-
1
;
}
int
index
=
0
;
while
(index
<
contents.length
&&
contents[index]
!=
null
)
{
if
(contents[index].equals(target))
return
index;
else
if
(target.compareTo(contents[index])
<
0
)
index
=
2
*
index
+
1
;
else
index
=
2
*
index
+
2
;
}
return
-
1
;
}
public
boolean
contains(Comparable element) {
return
(find(element)
!=
-
1
);
}
public
void
removeLeftSubtree() {
if
(contents[
1
]
==
null
)
{
System.out.println(
"
没有左子树
"
);
return
;
}
else
{
contents[
1
]
=
null
;
count
--
;
removeSubtree(
1
);
}
}
public
void
removeRightSubtree() {
if
(contents[
2
]
==
null
)
{
System.out.println(
"
没有右子树
"
);
return
;
}
else
{
contents[
2
]
=
null
;
count
--
;
removeSubtree(
2
);
}
}
private
void
removeSubtree(
int
index){
//
删除contents[index]的左右子树（递归）
int
lindex
=
2
*
index
+
1
;
int
rindex
=
2
*
index
+
2
;
if
(lindex
<
contents.length
&&
contents[lindex]
!=
null
)
{
contents[lindex]
=
null
;
count
--
;
removeSubtree(lindex);
}
//
if(contents[rindex] != null) !!!可能数组越界
if
(rindex
<
contents.length
&&
contents[rindex]
!=
null
)
{
contents[rindex]
=
null
;
count
--
;
removeSubtree(rindex);
}
}
public
void
addElement(Comparable element) {
int
index
=
0
;
if
(size()
==
0
)
{
contents[index]
=
element;
count
++
;
return
;
}
while
(index
<
contents.length)
{
if
(element.compareTo(contents[index])
<
0
)
{
int
lindex
=
2
*
index
+
1
;
if
(lindex
>=
contents.length)
expand();
if
(contents[lindex]
==
null
)
contents[lindex]
=
element;
else
index
=
lindex;
}
else
{
int
rindex
=
2
*
index
+
2
;
if
(rindex
>=
contents.length)
expand();
if
(contents[rindex]
==
null
)
contents[rindex]
=
element;
else
index
=
rindex;
}
}
count
++
;
}
public
Comparable removeElement(Comparable element) {
Comparable result
=
null
;
int
index
=
find(element);
//
找到指定删除元素在数组中的下标
if
(index
!=
-
1
)
{
result
=
(Comparable) contents[index];
remove(index);
//
count--;在remove里已经实现了
}
return
result;
}
private
void
remove(
int
index){
//
删除指定下标处的元素,并得到删除后的树（调整位置）
Iterator it
=
PreInorder();
//
得到前序遍历的迭代器
for
(
int
i
=
0
;i
<
contents.length;i
++
)
//
将树清空
contents[i]
=
null
;
count
=
0
;
while
(it.hasNext())
{
addElement((Comparable) it.next());
}
}
public
Comparable findMax() {
int
index
=
0
;
while
((
2
*
index
+
2
<
contents.length)
&&
(contents[
2
*
index
+
2
]
!=
null
))
index
=
2
*
index
+
2
;
return
(Comparable) contents[index];
}
public
Comparable findMin() {
int
index
=
0
;
while
((
2
*
index
+
1
<
contents.length)
&&
(contents[index
*
2
+
1
]
!=
null
))
index
=
index
*
2
+
1
;
return
(Comparable) contents[index];
}
public
Comparable removeMax() {
int
index
=
0
;
while
((
2
*
index
+
2
<
contents.length)
&&
(contents[
2
*
index
+
2
]
!=
null
))
index
=
2
*
index
+
2
;
Comparable result
=
(Comparable) contents[index];
remove(index);
return
result;
}
public
Comparable removeMin() {
int
index
=
0
;
while
((
2
*
index
+
1
<
contents.length)
&&
(contents[
2
*
index
+
1
]
!=
null
))
index
=
2
*
index
+
1
;
Comparable result
=
(Comparable) contents[index];
remove(index);
return
result;
}
public
static
void
main(String[] args) {
BinarySearchTree tree
=
new
BinarySearchTree();
//
二叉排序树的形状跟插入顺序有关，中序序列总是不变（有序）
tree.addElement(
10
);
tree.addElement(
5
);
tree.addElement(
3
);
tree.addElement(
7
);
tree.addElement(
6
);
tree.addElement(
9
);
tree.addElement(
8
);
tree.addElement(
13
);
tree.addElement(
11
);
tree.addElement(
20
);
tree.addElement(
25
);
tree.addElement(
16
);
System.out.println(
"
\n中序遍历结果为：
"
);
Iterator it
=
tree.iteratorInorder();
while
(it.hasNext())
System.out.print(it.next()
+
"
"
);
System.out.println(
"
\n前序遍历结果为：
"
);
it
=
tree.PreInorder();
while
(it.hasNext())
System.out.print(it.next()
+
"
"
);
System.out.println(
"
\n后序遍历结果为：
"
);
it
=
tree.PostInorder();
while
(it.hasNext())
System.out.print(it.next()
+
"
"
);
System.out.println(
"
\n\n
"
+
"
最小元素为：
"
+
tree.findMin());
System.out.println(
"
\n
"
+
"
最大元素为：
"
+
tree.findMax());
/*
tree.removeMin();
System.out.println("\n删除最小元素3后的前序序列： ");
it = tree.PreInorder();
while(it.hasNext())
System.out.print(it.next() + " ");
tree.removeMin();
System.out.println("\n\n接着删除最小元素5后的前序序列： ");
it = tree.PreInorder();
while(it.hasNext())
System.out.print(it.next() + " ");
*/
tree.removeElement(
10
);
tree.removeElement(
9
);
tree.removeElement(
13
);
tree.removeElement(
5
);
System.out.println(
"
\n\n删除节点后前序遍历结果为：
"
);
it
=
tree.PreInorder();
while
(it.hasNext())
System.out.print(it.next()
+
"
"
);
}
}
仍然构造链式实现的那个二叉排序树：
结果：
中序遍历结果为：
3 5 6 7 8 9 10 11 13 16 20 25
前序遍历结果为：
10 5 3 7 6 9 8 13 11 20 16 25
后序遍历结果为：
3 6 8 9 7 5 11 16 25 20 13 10
最小元素为： 3
最大元素为： 25
删除节点后前序遍历结果为：
8 3 7 6 11 20 16 25
