二分探索木ノード削除
このセクションでは、二分探索木のノード削除を紹介する前に、最小値と最大値の検索方法、および最小値と最大値の削除方法を紹介します。
最小値を例にとります(最大値も同様):
最小のkey値を検索するコードロジックは、左の子ノードへ再帰的に検索していきます:
...
// nodeをルートとする二分探索木の最小キー値を持つノードを返す
private Node minimum(Node node){
if( node.left == null )
return node;
return minimum(node.left);
}
...
// nodeをルートとする二分探索木の最小キー値を持つノードを返す
private Node minimum(Node node){
if( node.left == null )
return node;
return minimum(node.left);
}
...
二分探索木の最小key値を削除します。そのノードに右部分木がない場合は直接削除し、右部分木が存在する場合は、図のように:

ノード22を削除します。右の子が存在するため、右部分木の33ノードをノード22の代わりにすればよいだけです。

この最小値の削除をコードで表すと:
...
// nodeをルートとする二分探索木の最小ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMin(Node node){
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
...
// nodeをルートとする二分探索木の最小ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMin(Node node){
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
...
次に、二分探索木のノード削除について、以下の3つの場合に分けて説明します:
1、左の子のみを持つノードを削除する場合、下図のノード58のようなケースです。

要素58を削除し、左部分木を直接58の位置に置き換えます。二分探索木全体の性質は変わりません。

2、右の子のみを持つノードを削除する場合、下図のノード58のようなケースです。

要素58を削除し、右部分木を直接58の位置に置き換えます。二分探索木全体の性質は変わりません。

3、左右両方に子を持つノードを削除する場合、下図のノード58のようなケースです。

(1)右部分木の最小値を見つけます。ノード59です

(2)ノード59が削除予定のノード58の代わりになります

上記の規則を総合すると、nodeをルートとする二分探索木からキー値がkeyのノードを削除する核心コードの例は次のとおりです:
ソースコードパッケージのダウンロード:Download
src/サンプル/binary/BSTRemove.java ファイルコード:
package サンプル.binary;
import java.util.LinkedList;
/**
* 二分探索木ノード削除
*/
public class BSTRemove<Key extends Comparable<Key>, Value> {
// ツリー内のノードはプライベートクラスであり、外部は二分探索木ノードの具体的な実装を知る必要はありません
private class Node {
private Key key;
private Value value;
private Node left, right;
public Node(Key key, Value value) {
this.key = key;
this.value = value;
left = right = null;
}
public Node(Node node){
this.key = node.key;
this.value = node.value;
this.left = node.left;
this.right = node.right;
}
}
private Node root; // ルートノード
private int count; // ツリー内のノード数
// コンストラクタ。デフォルトで空の二分探索木を構築します
public BSTRemove() {
root = null;
count = 0;
}
// 二分探索木のノード数を返す
public int size() {
return count;
}
// 二分探索木が空かどうかを返す
public boolean isEmpty() {
return count == 0;
}
// 二分探索木に新しい(key, value)データペアを挿入する
public void insert(Key key, Value value){
root = insert(root, key, value);
}
// 二分探索木にキーkeyが存在するかどうかを確認する
public boolean contain(Key key){
return contain(root, key);
}
// 二分探索木でキーkeyに対応する値を検索する。この値が存在しない場合はnullを返す
public Value search(Key key){
return search( root , key );
}
// 二分探索木の行きがけ順走査
public void preOrder(){
preOrder(root);
}
// 二分探索木の通りがけ順走査
public void inOrder(){
inOrder(root);
}
// 二分探索木の帰りがけ順走査
public void postOrder(){
postOrder(root);
}
// 二分探索木のレベル順走査
public void levelOrder(){
// キューの代わりにLinkedListを使用します
LinkedList<Node> q = new LinkedList<Node>();
q.add(root);
while( !q.isEmpty() ){
Node node = q.remove();
System.out.println(node.key);
if( node.left != null )
q.add( node.left );
if( node.right != null )
q.add( node.right );
}
}
// 二分探索木の最小のキー値を見つける
public Key minimum(){
assert count != 0;
Node minNode = minimum( root );
return minNode.key;
}
// 二分探索木の最大のキー値を見つける
public Key maximum(){
assert count != 0;
Node maxNode = maximum(root);
return maxNode.key;
}
// 二分探索木から最小値を持つノードを削除する
public void removeMin(){
if( root != null )
root = removeMin( root );
}
// 二分探索木から最大値を持つノードを削除する
public void removeMax(){
if( root != null )
root = removeMax( root );
}
// 二分探索木からキー値がkeyのノードを削除する
public void remove(Key key){
root = remove(root, key);
}
//********************
//* 二分探索木の補助関数
//********************
// nodeをルートとする二分探索木にノード(key, value)を挿入する。再帰アルゴリズムを使用
// 新しいノードを挿入した後の二分探索木のルートを返す
private Node insert(Node node, Key key, Value value){
if( node == null ){
count ++;
return new Node(key, value);
}
if( key.compareTo(node.key) == 0 )
node.value = value;
else if( key.compareTo(node.key) < 0 )
node.left = insert( node.left , key, value);
else // key > node->key
node.right = insert( node.right, key, value);
return node;
}
// nodeをルートとする二分探索木にキー値がkeyのノードが含まれているかどうかを確認する。再帰アルゴリズムを使用
private boolean contain(Node node, Key key){
if( node == null )
return false;
if( key.compareTo(node.key) == 0 )
return true;
else if( key.compareTo(node.key) < 0 )
return contain( node.left , key );
else // key > node->key
return contain( node.right , key );
}
// nodeをルートとする二分探索木でkeyに対応するvalueを検索する。再帰アルゴリズム
// valueが存在しない場合はNULLを返す
private Value search(Node node, Key key){
if( node == null )
return null;
if( key.compareTo(node.key) == 0 )
return node.value;
else if( key.compareTo(node.key) < 0 )
return search( node.left , key );
else // key > node->key
return search( node.right, key );
}
// nodeをルートとする二分探索木を行きがけ順に走査する。再帰アルゴリズム
private void preOrder(Node node){
if( node != null ){
System.out.println(node.key);
preOrder(node.left);
preOrder(node.right);
}
}
// nodeをルートとする二分探索木を通りがけ順に走査する。再帰アルゴリズム
private void inOrder(Node node){
if( node != null ){
inOrder(node.left);
System.out.println(node.key);
inOrder(node.right);
}
}
// nodeをルートとする二分探索木を帰りがけ順に走査する。再帰アルゴリズム
private void postOrder(Node node){
if( node != null ){
postOrder(node.left);
postOrder(node.right);
System.out.println(node.key);
}
}
// nodeをルートとする二分探索木の最小キー値を持つノードを返す
private Node minimum(Node node){
if( node.left == null )
return node;
return minimum(node.left);
}
// nodeをルートとする二分探索木の最大キー値を持つノードを返す
private Node maximum(Node node){
if( node.right == null )
return node;
return maximum(node.right);
}
// nodeをルートとする二分探索木の最小ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMin(Node node){
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// nodeをルートとする二分探索木の最大ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMax(Node node){
if( node.right == null ){
Node leftNode = node.left;
node.left = null;
count --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
// nodeをルートとする二分探索木からキー値がkeyのノードを削除する。再帰アルゴリズム
// 削除後の新しい二分探索木のルートを返す
Node remove(Node node, Key key){
if( node == null )
return null;
if( key.compareTo(node.key) < 0 ){
node.left = remove( node.left , key );
return node;
}
else if( key.compareTo(node.key) > 0 ){
node.right = remove( node.right, key );
return node;
}
else{ // key == node->key
// 削除対象ノードの左部分木が空の場合
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
// 削除対象ノードの右部分木が空の場合
if( node.right == null ){
Node leftNode = node.left;
node.left = null;
count--;
return leftNode;
}
// 削除対象ノードの左右の部分木が両方とも空でない場合
// 削除対象ノードより大きい最小のノード、すなわち削除対象ノードの右部分木の最小ノードを見つける
// このノードを削除対象ノードの位置に置き換える
Node successor = new Node(minimum(node.right));
count ++;
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
count --;
return successor;
}
}
}
import java.util.LinkedList;
/**
* 二分探索木ノード削除
*/
public class BSTRemove<Key extends Comparable<Key>, Value> {
// ツリー内のノードはプライベートクラスであり、外部は二分探索木ノードの具体的な実装を知る必要はありません
private class Node {
private Key key;
private Value value;
private Node left, right;
public Node(Key key, Value value) {
this.key = key;
this.value = value;
left = right = null;
}
public Node(Node node){
this.key = node.key;
this.value = node.value;
this.left = node.left;
this.right = node.right;
}
}
private Node root; // ルートノード
private int count; // ツリー内のノード数
// コンストラクタ。デフォルトで空の二分探索木を構築します
public BSTRemove() {
root = null;
count = 0;
}
// 二分探索木のノード数を返す
public int size() {
return count;
}
// 二分探索木が空かどうかを返す
public boolean isEmpty() {
return count == 0;
}
// 二分探索木に新しい(key, value)データペアを挿入する
public void insert(Key key, Value value){
root = insert(root, key, value);
}
// 二分探索木にキーkeyが存在するかどうかを確認する
public boolean contain(Key key){
return contain(root, key);
}
// 二分探索木でキーkeyに対応する値を検索する。この値が存在しない場合はnullを返す
public Value search(Key key){
return search( root , key );
}
// 二分探索木の行きがけ順走査
public void preOrder(){
preOrder(root);
}
// 二分探索木の通りがけ順走査
public void inOrder(){
inOrder(root);
}
// 二分探索木の帰りがけ順走査
public void postOrder(){
postOrder(root);
}
// 二分探索木のレベル順走査
public void levelOrder(){
// キューの代わりにLinkedListを使用します
LinkedList<Node> q = new LinkedList<Node>();
q.add(root);
while( !q.isEmpty() ){
Node node = q.remove();
System.out.println(node.key);
if( node.left != null )
q.add( node.left );
if( node.right != null )
q.add( node.right );
}
}
// 二分探索木の最小のキー値を見つける
public Key minimum(){
assert count != 0;
Node minNode = minimum( root );
return minNode.key;
}
// 二分探索木の最大のキー値を見つける
public Key maximum(){
assert count != 0;
Node maxNode = maximum(root);
return maxNode.key;
}
// 二分探索木から最小値を持つノードを削除する
public void removeMin(){
if( root != null )
root = removeMin( root );
}
// 二分探索木から最大値を持つノードを削除する
public void removeMax(){
if( root != null )
root = removeMax( root );
}
// 二分探索木からキー値がkeyのノードを削除する
public void remove(Key key){
root = remove(root, key);
}
//********************
//* 二分探索木の補助関数
//********************
// nodeをルートとする二分探索木にノード(key, value)を挿入する。再帰アルゴリズムを使用
// 新しいノードを挿入した後の二分探索木のルートを返す
private Node insert(Node node, Key key, Value value){
if( node == null ){
count ++;
return new Node(key, value);
}
if( key.compareTo(node.key) == 0 )
node.value = value;
else if( key.compareTo(node.key) < 0 )
node.left = insert( node.left , key, value);
else // key > node->key
node.right = insert( node.right, key, value);
return node;
}
// nodeをルートとする二分探索木にキー値がkeyのノードが含まれているかどうかを確認する。再帰アルゴリズムを使用
private boolean contain(Node node, Key key){
if( node == null )
return false;
if( key.compareTo(node.key) == 0 )
return true;
else if( key.compareTo(node.key) < 0 )
return contain( node.left , key );
else // key > node->key
return contain( node.right , key );
}
// nodeをルートとする二分探索木でkeyに対応するvalueを検索する。再帰アルゴリズム
// valueが存在しない場合はNULLを返す
private Value search(Node node, Key key){
if( node == null )
return null;
if( key.compareTo(node.key) == 0 )
return node.value;
else if( key.compareTo(node.key) < 0 )
return search( node.left , key );
else // key > node->key
return search( node.right, key );
}
// nodeをルートとする二分探索木を行きがけ順に走査する。再帰アルゴリズム
private void preOrder(Node node){
if( node != null ){
System.out.println(node.key);
preOrder(node.left);
preOrder(node.right);
}
}
// nodeをルートとする二分探索木を通りがけ順に走査する。再帰アルゴリズム
private void inOrder(Node node){
if( node != null ){
inOrder(node.left);
System.out.println(node.key);
inOrder(node.right);
}
}
// nodeをルートとする二分探索木を帰りがけ順に走査する。再帰アルゴリズム
private void postOrder(Node node){
if( node != null ){
postOrder(node.left);
postOrder(node.right);
System.out.println(node.key);
}
}
// nodeをルートとする二分探索木の最小キー値を持つノードを返す
private Node minimum(Node node){
if( node.left == null )
return node;
return minimum(node.left);
}
// nodeをルートとする二分探索木の最大キー値を持つノードを返す
private Node maximum(Node node){
if( node.right == null )
return node;
return maximum(node.right);
}
// nodeをルートとする二分探索木の最小ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMin(Node node){
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// nodeをルートとする二分探索木の最大ノードを削除する
// 削除後の新しい二分探索木のルートを返す
private Node removeMax(Node node){
if( node.right == null ){
Node leftNode = node.left;
node.left = null;
count --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
// nodeをルートとする二分探索木からキー値がkeyのノードを削除する。再帰アルゴリズム
// 削除後の新しい二分探索木のルートを返す
Node remove(Node node, Key key){
if( node == null )
return null;
if( key.compareTo(node.key) < 0 ){
node.left = remove( node.left , key );
return node;
}
else if( key.compareTo(node.key) > 0 ){
node.right = remove( node.right, key );
return node;
}
else{ // key == node->key
// 削除対象ノードの左部分木が空の場合
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
// 削除対象ノードの右部分木が空の場合
if( node.right == null ){
Node leftNode = node.left;
node.left = null;
count--;
return leftNode;
}
// 削除対象ノードの左右の部分木が両方とも空でない場合
// 削除対象ノードより大きい最小のノード、すなわち削除対象ノードの右部分木の最小ノードを見つける
// このノードを削除対象ノードの位置に置き換える
Node successor = new Node(minimum(node.right));
count ++;
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
count --;
return successor;
}
}
}