二叉搜索树数据结构完整实现

package com.mars.search;

public class BinarySeachTree {
private Node mRoot;

private Node getRoot() {
return mRoot;
}

public int search(Node root, int key) {
if (root == null) {
return 0xffffffff;
}
if (key < root.key) {
return search(root.leftNode, key);
}
if (key > root.key) {
return search(root.rightNode, key);
} else {
return key;
}
}

public void insert(int data) {
if (mRoot == null) {
mRoot = new Node(data, null, null);
// mRoot.key = data;
}
Node root = mRoot;
while (root != null) {
if (data == root.key) {
return;
} else if (data < root.key) {
if (root.leftNode == null) {
root.leftNode = new Node(data, null, null);
return;
} else {
root = root.leftNode;
}
} else {
if (root.rightNode == null) {
root.rightNode = new Node(data, null, null);
return;
} else {
root = root.rightNode;
}
}
}
}

/*
* http://courses.csail.mit.edu/6.006/spring11/rec/rec03.pdf Description:
* Remove the node x from the binary search tree, making the necessary
* adjustments to the binary search tree to maintain its properties. (Note
* that this operation removes a specified node from the tree. If you wanted
* to delete a key k from the tree, you would have to first call find(k) to
* find the node with key k and then call delete to remove that node) Case 1:
* x has no children. Just delete it (i.e. change parent node so that it
* doesn’t point to x) Case 2: x has one child. Splice out x by linking x’s
* parent to x’s child Case 3: x has two children. Splice out x’s successor
* and replace x with x’s successor
*
* BST删除分析可以看这里 http://webdocs.cs.ualberta.ca/~holte/T26/del-from-bst.html */
public boolean delete(int key) {
Node root = deleteNode(this.mRoot, key);

if (root != null) {
return true;
}
return false;
}

/**
*
* 删除有左右子树节点的时候其实等价于：1将右子树的最左叶子节点的值覆盖要删除节点的值，
* 然后删除右子树最左叶子节点。 递归的过程中找到删除节点然后将右子树的最左子叶子节点的
* 值赋给删除节点，然后删除右子树的最左叶子节点。这步在递归退出的时候就做了，如果想不
* 通可以细细的看下第一个if语句
*
* */

private Node deleteNode(Node root, int key) {
if (key < root.key) {
if (root.leftNode != null) {
root.leftNode = deleteNode(root.leftNode, key);
} else {
return null;
}
} else if (key > root.key) {
if (root.rightNode != null) {
root.rightNode = deleteNode(root.rightNode, key);
} else {
return null;
}
} else {
if (root.leftNode == null) {
root = root.rightNode;
} else if (root.rightNode == null) {
root = root.leftNode;
} else {
Node newRoot = findMin(root);
root.key = newRoot.key;
// 此步递归调用相当于把右子树的最左子树的左叶子给删了，因为递归退出的时候leftNode = null;
//如果Node的結構里有指向parent的引用，刪除會方便些
root.rightNode = deleteNode(root.rightNode, root.key);
}
}
return root;
}

// 左子树的最右叶子节点
private Node findMin(Node root) {
Node newRoot = root.rightNode;
while (newRoot.leftNode != null) {
newRoot = newRoot.leftNode;
}
return newRoot;
}

public void travel(Node root) {
Node node = root;
if (node == null) {
return;
}
travel(node.leftNode);
System.out.print(node.key + " ");
travel(node.rightNode);
}

public static class Node {
int key;
Node leftNode;
Node rightNode;

Node(int key, Node left, Node right) {
this.key = key;
this.leftNode = left;
this.rightNode = right;
}
}

public static void main(String[] args) {
BinarySeachTree bst = new BinarySeachTree();
int[] a = {
0, 4, 3, 2, 5, 1, 7, 6, 8, 9
};

for (int i : a) {
bst.insert(i);
}
bst.travel(bst.getRoot());

int i = bst.search(bst.getRoot(), 3);
System.out.println("\nsearch :" + i);

System.out.println("after delete:");
bst.delete(4);
bst.travel(bst.getRoot());
}
}