java实现排序二叉树

* 二叉树排序算法看似很简单，特别是看到其他博客写的实现代码，但是如果把细节各种情况考虑进去，还是不容易的。
* 数据使用链式二叉树来存储，在增加节点的时候，小的在父节点的左边，大的在父节点的右边。刚增加的数据都是叶子节点
* 在删除的时候，可以有三种情况，分别是：（用a表示当前将要删除的节点）
* 第一，如果a是叶子节点，可以直接删除；
* 第二，如果a只有一个孩子节点，那么需要把孩子节点上移到a的位置；
* 第三，如果a有两个子节点，那么需要找到a的后继节点b（中序遍历）,把b移到a的位置，
* 这时候需要注意一种特殊情况，那就是后继节点b是将要删除的节点a的右孩子，需要单独处理。

还需要特别注意的情况是：如果将要删除的节点是根节点。

package com.huai.sort.binaryTree;

/**
* 二叉树排序算法
* <p>数据使用链式二叉树来存储，在增加节点的时候，小的在父节点的左边，大的在父节点的右边。刚增加的数据都是叶子节点</p>
* <p>在删除的时候，可以有三种情况，分别是：（用a表示当前将要删除的节点）
* 第一，如果a是叶子节点，可以直接删除；
* 第二，如果a只有一个孩子节点，那么需要把孩子节点上移到a的位置；
* 第三，如果a有两个子节点，那么需要找到a的后继节点b（中序遍历）,把b移到a的位置，
* 这时候需要注意一种特殊情况，那就是后继节点b是将要删除的节点a的右孩子，需要单独处理。</p>
* Created by liangyh on 16-1-20.
*/
public class BinaryTreeSortTest {

private Node head;

public void print(){
Node current = head;
travel(head);
}

/**
* 中序中序遍历
* @param node
*/
private void travel(Node node){
if(node == null) return;

travel(node.left);
System.out.print(node.data+" ");
travel(node.right);
}

/**
* 增加一个节点，小的在父节点的左边，大的在父节点的右边
* @param data
*/
public void add(int data){
Node newNode = new Node(data);

if(head == null){
head = newNode;
return;
}

Node current = head;
while(true){
if(current.data < data){
if(current.right != null) {
current = current.right;
} else{
current.right = newNode;
return;
}
}else{
if(current.left != null) {
current = current.left;
} else {
current.left = newNode;
return;
}
}
}
}

/**
* 删除一个节点
* @param data
* @return
*/
public boolean delete(int data){
if(head == null) return false;
Node parent = head;
Node current = head;
boolean isLeft = true;
while(current.data != data){
parent = current;
if(current.data < data){
current = current.right;
isLeft = false;
}else{
current = current.left;
isLeft = true;
}

if(current == null) return false;
}

deleteCurrentNode2(current,isLeft, parent);

return true;
}

/**
* 删除当前节点
* @param current 将要删除的节点
* @param previous 当前节点的前一个节点
* @param isLeftChild 当前节点是否为左孩子
*/
private void deleteCurrentNode(Node current, boolean isLeftChild, Node previous){
//特殊处理，如果将要删除的数据是根节点
if(current == head){
if(head.left != null && head.right != null){
previous = head;
Node deletingNode = head;//保存将要删除的节点
current = head.right;
//寻找将要删除的节点的后继节点（中序遍历）
while(current.left != null){
previous = current;
current = current.left;
}
deletingNode.data = current.data;
if(previous == deletingNode)//如果后继节点是待删除节点的右子树。
previous.right = current.right;
else
previous.left = current.right;
}else if(head.left != null){
head = head.left;
}else if(head.right != null){
head = head.right;
}else{
//head.left == null && head.right == null
head = null;
}
return;
}

if(current.left != null && current.right != null){
previous = current;
Node deletingNode = current;//保存将要删除的节点
current = current.right;
//寻找将要删除的节点的后继节点（中序遍历）
while(current.left != null){
previous = current;
current = current.left;
}
deletingNode.data = current.data;
if(previous == deletingNode)//如果后继节点是待删除节点的右子树。
previous.right = current.right;
else
previous.left = current.right;
}else if(current.left != null){
//current.left != null && current.right == null
if(isLeftChild)
previous.left = current.left;
else
previous.right = current.left;
}else if(current.right != null){
//current.left == null && current.right != null
if(isLeftChild)
previous.left = current.right;
else
previous.right = current.right;
}else{
//current.left == null && current.right == null
if(isLeftChild)
previous.left = null;
else
previous.right = null;
}
}

/**
* 删除当前节点
* @param current 将要删除的节点
* @param previous 当前节点的前一个节点
* @param isLeftChild 当前节点是否为左孩子
*/
private void deleteCurrentNode2(Node current, boolean isLeftChild, Node previous){
//如果左右孩子节点都不为空
if(current.left != null && current.right != null){
Node deletingNode = current;//保存将要删除的节点
previous = current;
current = current.right;
//寻找将要删除的节点的后继节点（中序遍历）
while(current.left != null){
previous = current;
current = current.left;
}
deletingNode.data = current.data;
if(previous == deletingNode)//如果后继节点是待删除节点的右子树。
previous.right = current.right;
else
previous.left = current.right;
}else if(current.left != null){
//current.left != null && current.right == null
if(current == head) {
// current = current.left;
head = head.left;
}
else if(isLeftChild)
previous.left = current.left;
else
previous.right = current.left;
}else if(current.right != null){
//current.left == null && current.right != null
if(current == head) {
// current = current.right;
head = head.right;
}
else if(isLeftChild) {
previous.left = current.right;
}
else
previous.right = current.right;
}else{
//current.left == null && current.right == null
if(current == head)
head = null;
else if(isLeftChild)
previous.left = null;
else
previous.right = null;

}
}

public Node getTargetNode(int data){

Node current = head;

while(current.data != data){
if(current.data < data){
current = current.right;
}else{
current = current.left;
}

if(current == null) return null;
}
return current;
}

public class Node{
Node left;
Node right;
int data;

public Node(){
this.left = null;
this.right = null;
}

public Node(int data){
this.data = data;
this.left = null;
this.right = null;
}
}

public static void main(String args[]){
BinaryTreeSortTest sortTest = new BinaryTreeSortTest();
sortTest.add(8);
sortTest.add(5);
// sortTest.add(6);
// sortTest.add(3);
// sortTest.add(9);
// sortTest.add(4);
// sortTest.add(7);
// sortTest.add(7);
// sortTest.add(7);
// sortTest.add(8);

sortTest.print();
System.out.println();

boolean flag = sortTest.delete(8);
sortTest.print();
}
}