一般的な方法は、ノードに親リンクがあるかどうかによって異なります。
親リンクを保存する場合
次に、以下を選択します。
- 現在のノードに右の子がある場合、右の子の左端の子。右の子に左の子がない場合、右の子があなたの順序付けられた後継者です。
- 親の祖先ノードを上に移動し、現在のノードが左の子である親を見つけた場合、その親は元のノードの次の後続ノードです。
適切な子供がいる場合は、このアプローチを実行します（上記のケース1）。
適切な子供がいない場合は、このアプローチを実行してください（上記のケース2）。
親リンクを保存しない場合
次に、ツリーの完全なスキャンを実行し、通常はスタックを使用してノードを追跡します。これにより、親リンクに依存する最初のメソッドと基本的に同じことを実行するために必要な情報が得られます。
ラッセのPythonコード answer ：
def findNext(node):
if node.rightChild != None:
return findMostLeft(node.rightChild)
else:
parent = node.parent
while parent != None:
if parent.leftChild == node:
break
node = parent
parent = node.parent
return parent
ここをチェックしてください： バイナリ検索ツリーのInOrder後継者
バイナリツリーでは、ノードのInorder後続ノードは、バイナリツリーのInorderトラバーサルの次のノードです。 Inoorderトラバーサルの最後のノードのInorder SuccessorはNULLです。二分探索木では、入力ノードのInorder Successorは、入力ノードのキーよりも大きい最小のキーを持つノードとして定義することもできます。
o（log n）で順序付けられた後続を見つけるために親リンクまたはスタックは必要ありません（バランスツリーを想定）。キーよりも大きい順序トラバーサルで検出された最新の値を持つ一時変数を保持します。順序トラバーサルでノードに正しい子がないことが判明した場合、これは順序サクセサーになります。それ以外の場合、右の子の左端の子孫。
これは、親リンクや中間構造（スタックなど）を必要としない実装です。この順序付けされた後続関数は、ノードではなくキーで動作するため、ほとんどの場合に求められるものとは少し異なります。また、ツリーに存在しない場合でも、キーの後続を検索します。ただし、必要に応じて変更するのはそれほど難しくありません。
public class Node<T extends Comparable<T>> {
private T data;
private Node<T> left;
private Node<T> right;
public Node(T data, Node<T> left, Node<T> right) {
this.data = data;
this.left = left;
this.right = right;
}
/*
* Returns the left-most node of the current node. If there is no left child, the current node is the left-most.
*/
private Node<T> getLeftMost() {
Node<T> curr = this;
while(curr.left != null) curr = curr.left;
return curr;
}
/*
* Returns the right-most node of the current node. If there is no right child, the current node is the right-most.
*/
private Node<T> getRightMost() {
Node<T> curr = this;
while(curr.right != null) curr = curr.right;
return curr;
}
/**
* Returns the in-order successor of the specified key.
* @param key The key.
* @return
*/
public T getSuccessor(T key) {
Node<T> curr = this;
T successor = null;
while(curr != null) {
// If this.data < key, search to the right.
if(curr.data.compareTo(key) < 0 && curr.right != null) {
curr = curr.right;
}
// If this.data > key, search to the left.
else if(curr.data.compareTo(key) > 0) {
// If the right-most on the left side has bigger than the key, search left.
if(curr.left != null && curr.left.getRightMost().data.compareTo(key) > 0) {
curr = curr.left;
}
// If there's no left, or the right-most on the left branch is smaller than the key, we're at the successor.
else {
successor = curr.data;
curr = null;
}
}
// this.data == key...
else {
// so get the right-most data.
if(curr.right != null) {
successor = curr.right.getLeftMost().data;
}
// there is no successor.
else {
successor = null;
}
curr = null;
}
}
return successor;
}
public static void main(String[] args) {
Node<Integer> one, three, five, seven, two, six, four;
one = new Node<Integer>(Integer.valueOf(1), null, null);
three = new Node<Integer>(Integer.valueOf(3), null, null);
five = new Node<Integer>(Integer.valueOf(5), null, null);
seven = new Node<Integer>(Integer.valueOf(7), null, null);
two = new Node<Integer>(Integer.valueOf(2), one, three);
six = new Node<Integer>(Integer.valueOf(6), five, seven);
four = new Node<Integer>(Integer.valueOf(4), two, six);
Node<Integer> head = four;
for(int i = 0; i <= 7; i++) {
System.out.println(head.getSuccessor(i));
}
}
}
バイナリサーチツリーでは、特定のノードの次に高いノードを見つけるアルゴリズムは、基本的にそのノードの正しいサブツリーの最も低いノードを見つけることです。
アルゴリズムは単純に次のとおりです。
- 指定されたノードの正しい子から開始します（一時的な現在のノードにします）
- 現在のノードに左の子がない場合、それは次に高いノードです。
- 現在のノードに左の子がある場合は、それを現在のノードにします。
次に高いノードが見つかるまで2と3を繰り返します。
順序トラバーサルを実行する場合、左側のサブツリー、次にルートノード、最後にツリー内の各ノードの右側のサブツリーにアクセスします。順序トラバーサルを実行すると、バイナリ検索ツリーのキーが昇順で得られるため、バイナリ検索ツリーに属するノードの順序付けられた後続ノードを取得する場合、シーケンスの次のノードが何であるかを意味します指定されたノード。
ノードRがあり、その次のノードが必要で、次のようなケースがあるとします。
[1]ルートRには右のノードがあるため、R-> rightの左端のノードに移動するだけです。
[2]ルートRには正しいノードがありません。この場合、ノードRがその親の左の子になるまで、親リンクをたどってツリーをさかのぼります。ノードPを順序どおりに継承します。
[3]ツリーの右端のノードにいます。この場合、後継ノードはありません。
実装は次のノード定義に基づいています
class node
{
private:
node* left;
node* right;
node* parent
int data;
public:
//public interface not shown, these are just setters and getters
.......
};
//go up the tree until we have our root node a left child of its parent
node* getParent(node* root)
{
if(root->parent == NULL)
return NULL;
if(root->parent->left == root)
return root->parent;
else
return getParent(root->parent);
}
node* getLeftMostNode(node* root)
{
if(root == NULL)
return NULL;
node* left = getLeftMostNode(root->left);
if(left)
return left;
return root;
}
//return the in order successor if there is one.
//parameters - root, the node whose in order successor we are 'searching' for
node* getInOrderSucc(node* root)
{
//no tree, therefore no successor
if(root == NULL)
return NULL;
//if we have a right tree, get its left most node
if(root->right)
return getLeftMostNode(root->right);
else
//bubble up so the root node becomes the left child of its
//parent, the parent will be the inorder successor.
return getParent(root);
}
ノードに左、右、および親ポインターがあると仮定したC++ソリューション：
これは、バイナリ検索ツリーの次のキーを順番に返す関数Node* getNextNodeInOrder(Node)を示しています。
#include <cstdlib>
#include <iostream>
using namespace std;
struct Node{
int data;
Node *parent;
Node *left, *right;
};
Node *createNode(int data){
Node *node = new Node();
node->data = data;
node->left = node->right = NULL;
return node;
}
Node* getFirstRightParent(Node *node){
if (node->parent == NULL)
return NULL;
while (node->parent != NULL && node->parent->left != node){
node = node->parent;
}
return node->parent;
}
Node* getLeftMostRightChild(Node *node){
node = node->right;
while (node->left != NULL){
node = node->left;
}
return node;
}
Node *getNextNodeInOrder(Node *node){
//if you pass in the last Node this will return NULL
if (node->right != NULL)
return getLeftMostRightChild(node);
else
return getFirstRightParent(node);
}
void inOrderPrint(Node *root)
{
if (root->left != NULL) inOrderPrint(root->left);
cout << root->data << " ";
if (root->right != NULL) inOrderPrint(root->right);
}
int main(int argc, char** argv) {
//Purpose of this program is to demonstrate the function getNextNodeInOrder
//of a binary tree in-order. Below the tree is listed with the order
//of the items in-order. 1 is the beginning, 11 is the end. If you
//pass in the node 4, getNextNode returns the node for 5, the next in the
//sequence.
//test tree:
//
// 4
// / \
// 2 11
// / \ /
// 1 3 10
// /
// 5
// \
// 6
// \
// 8
// / \
// 7 9
Node *root = createNode(4);
root->parent = NULL;
root->left = createNode(2);
root->left->parent = root;
root->right = createNode(11);
root->right->parent = root;
root->left->left = createNode(1);
root->left->left->parent = root->left;
root->right->left = createNode(10);
root->right->left->parent = root->right;
root->left->right = createNode(3);
root->left->right->parent = root->left;
root->right->left->left = createNode(5);
root->right->left->left->parent = root->right->left;
root->right->left->left->right = createNode(6);
root->right->left->left->right->parent = root->right->left->left;
root->right->left->left->right->right = createNode(8);
root->right->left->left->right->right->parent =
root->right->left->left->right;
root->right->left->left->right->right->left = createNode(7);
root->right->left->left->right->right->left->parent =
root->right->left->left->right->right;
root->right->left->left->right->right->right = createNode(9);
root->right->left->left->right->right->right->parent =
root->right->left->left->right->right;
inOrderPrint(root);
//UNIT TESTING FOLLOWS
cout << endl << "unit tests: " << endl;
if (getNextNodeInOrder(root)->data != 5)
cout << "failed01" << endl;
else
cout << "passed01" << endl;
if (getNextNodeInOrder(root->right) != NULL)
cout << "failed02" << endl;
else
cout << "passed02" << endl;
if (getNextNodeInOrder(root->right->left)->data != 11)
cout << "failed03" << endl;
else
cout << "passed03" << endl;
if (getNextNodeInOrder(root->left)->data != 3)
cout << "failed04" << endl;
else
cout << "passed04" << endl;
if (getNextNodeInOrder(root->left->left)->data != 2)
cout << "failed05" << endl;
else
cout << "passed05" << endl;
if (getNextNodeInOrder(root->left->right)->data != 4)
cout << "failed06" << endl;
else
cout << "passed06" << endl;
if (getNextNodeInOrder(root->right->left->left)->data != 6)
cout << "failed07" << endl;
else
cout << "passed07" << endl;
if (getNextNodeInOrder(root->right->left->left->right)->data != 7)
cout << "failed08 it came up with: " <<
getNextNodeInOrder(root->right->left->left->right)->data << endl;
else
cout << "passed08" << endl;
if (getNextNodeInOrder(root->right->left->left->right->right)->data != 9)
cout << "failed09 it came up with: "
<< getNextNodeInOrder(root->right->left->left->right->right)->data
<< endl;
else
cout << "passed09" << endl;
return 0;
}
どのプリント：
1 2 3 4 5 6 7 8 9 10 11
unit tests:
passed01
passed02
passed03
passed04
passed05
passed06
passed07
passed08
passed09
親ポインターを使用せずに、O（log n）で後続ノードを見つけることができます（バランスツリーの場合）。
この考え方は、親ポインターがある場合とよく似ています。
これを実現する再帰関数を次のように定義できます。
- 現在のノードがターゲットである場合、存在する場合は、その右サブツリーの左端/最小ノードを返します。
- ターゲットが現在のノードより小さい場合は左に再帰し、大きい場合は右に再帰します。
- ターゲットが左側にあり、後続ノードがまだ見つからない場合は、現在のノードを返します。
疑似コード：
Key successor(Node current, Key target):
if current == null
return null
if target == current.key
if current.right != null
return leftMost(current.right).key
else
return specialKey
else
if target < current.key
s = successor(current.left, target)
if s == specialKey
return current.key
else
return s
else
return successor(current.right, target)
Node leftMost(Node current):
while current.left != null
current = current.left
return current
Node successor(int data) {
return successor(root, data);
}
// look for the successor to data in the tree rooted at curr
private Node successor(Node curr, int data) {
if (curr == null) {
return null;
} else if (data < curr.data) {
Node suc = successor(curr.left, data);
// if a successor is found use it otherwise we know this node
// is the successor since the target node was in this nodes left subtree
return suc == null ? curr : suc;
} else if (data > curr.data) {
return successor(curr.right, data);
} else {
// we found the node so the successor might be the min of the right subtree
return findMin(curr.right);
}
}
private Node findMin(Node curr) {
if (curr == null) {
return null;
}
while (curr.left != null) {
curr = curr.left;
}
return curr;
}
C＃実装（非再帰的！）。各ノードがその親へのリンクを持っているバイナリ検索ツリーで、指定されたノードの「次の」ノードを検索します。
public static Node WhoIsNextInOrder(Node root, Node node)
{
if (node.Right != null)
{
return GetLeftMost(node.Right);
}
else
{
Node p = new Node(null,null,-1);
Node Next = new Node(null, null, -1);
bool found = false;
p = FindParent(root, node);
while (found == false)
{
if (p.Left == node) { Next = p; return Next; }
node = p;
p = FindParent(root, node);
}
return Next;
}
}
public static Node FindParent(Node root, Node node)
{
if (root == null || node == null)
{
return null;
}
else if ( (root.Right != null && root.Right.Value == node.Value) || (root.Left != null && root.Left.Value == node.Value))
{
return root;
}
else
{
Node found = FindParent(root.Right, node);
if (found == null)
{
found = FindParent(root.Left, node);
}
return found;
}
}
public static Node GetLeftMost (Node node)
{
if (node.Left == null)
{
return node;
}
return GetLeftMost(node.Left);
}
あなたは追加情報を読むことができます ここ（Rus肺）
Node next(Node x)
if x.right != null
return minimum(x.right)
y = x.parent
while y != null and x == y.right
x = y
y = y.parent
return y
Node prev(Node x)
if x.left != null
return maximum(x.left)
y = x.parent
while y != null and x == y.left
x = y
y = y.parent
return y
これらの答えはすべて、私には過度に複雑に思えます。親ポインタやスタックのような補助的なデータ構造は本当に必要ありません。必要なのは、ルートから順番にツリーをトラバースし、ターゲットノードが見つかるとすぐにフラグを設定し、アクセスするツリーの次のノードが順序付けられた後続ノードになります。ここに私が書いた迅速で汚いルーチンがあります。
Node* FindNextInorderSuccessor(Node* root, int target, bool& done)
{
if (!root)
return NULL;
// go left
Node* result = FindNextInorderSuccessor(root->left, target, done);
if (result)
return result;
// visit
if (done)
{
// flag is set, this must be our in-order successor node
return root;
}
else
{
if (root->value == target)
{
// found target node, set flag so that we stop at next node
done = true;
}
}
// go right
return FindNextInorderSuccessor(root->right, target, done);
}
JavaScriptソリューション-指定されたノードに正しいノードがある場合、右のサブツリーの最小ノードを返します-そうでない場合、2つの可能性があります。-指定されたノードは、親ノードの左の子です。もしそうなら、親ノードを返します。それ以外の場合、指定されたノードは親ノードの右の子です。もしそうなら、親ノードの右の子を返します
function nextNode(node) {
var nextLargest = null;
if (node.right != null) {
// Return the smallest item in the right subtree
nextLargest = node.right;
while (nextLargest.left !== null) {
nextLargest = nextLargest.left;
}
return nextLargest;
} else {
// Node is the left child of the parent
if (node === node.parent.left) return node.parent;
// Node is the right child of the parent
nextLargest = node.parent;
while (nextLargest.parent !== null && nextLargest !== nextLargest.parent.left) {
nextLargest = nextLargest.parent
}
return nextLargest.parent;
}
}
私がグーグルでチェックしたすべての「チュートリアル」とこのスレッドのすべての回答は、次のロジックを使用します：「ノードに正しい子がない場合、その順序の後続はその1つになります祖先。親リンクを使用して、親の左の子であるノードを取得するまで上に移動し続けます。その後、この親ノードが順序付けられた後続ノードになります。 "
これは、「私の親が私よりも大きい場合、私は左の子です」（バイナリ検索ツリーのプロパティ）と考えるのと同じです。これは、上記のプロパティがtrueになるまで、親チェーンを上に移動できることを意味します。私の意見では、どちらがよりエレガントなコードになります。
親リンクを利用するコードパスの値の代わりにブランチを見て、誰もが「am the the left child」をチェックしている理由は、 no-link-to-parentアルゴリズムからの「借用」ロジック。
また、以下のインクルードコードから、他の回答で示唆されているようにスタックデータ構造は不要があることがわかります。
以下は、両方のユースケースで動作する単純なC++関数です（親へのリンクを使用する場合と使用しない場合）。
Node* nextInOrder(const Node *node, bool useParentLink) const
{
if (!node)
return nullptr;
// when has a right sub-tree
if (node->right) {
// get left-most node from the right sub-tree
node = node->right;
while (node->left)
node = node->left;
return node;
}
// when does not have a right sub-tree
if (useParentLink) {
Node *parent = node->parent;
while (parent) {
if (parent->value > node->value)
return parent;
parent = parent->parent;
}
return nullptr;
} else {
Node *nextInOrder = nullptr;
// 'root' is a class member pointing to the root of the tree
Node *current = root;
while (current != node) {
if (node->value < current->value) {
nextInOrder = current;
current = current->left;
} else {
current = current->right;
}
}
return nextInOrder;
}
}
Node* previousInOrder(const Node *node, bool useParentLink) const
{
if (!node)
return nullptr;
// when has a left sub-tree
if (node->left) {
// get right-most node from the left sub-tree
node = node->left;
while (node->right)
node = node->right;
return node;
}
// when does not have a left sub-tree
if (useParentLink) {
Node *parent = node->parent;
while (parent) {
if (parent->value < node->value)
return parent;
parent = parent->parent;
}
return nullptr;
} else {
Node *prevInOrder = nullptr;
// 'root' is a class member pointing to the root of the tree
Node *current = root;
while (current != node) {
if (node->value < current->value) {
current = current->left;
} else {
prevInOrder = current;
current = current->right;
}
}
return prevInOrder;
}
}
これを3つの場合に分けることができます。
ノードが親である場合：この場合、ノードに右ノードがあるかどうかを確認し、右ノードの左端の子に移動します。右側のノードに子がない場合、右側のノードはその次の子になります。正しいノードがない場合は、ツリーを上に移動して、順序付けられた後続ノードを見つける必要があります。
ノードが左の子の場合：この場合、親はinorder後続ノードです。
ノード（xと呼ぶ）が（その直接の親の）右の子である場合：左のサブツリーがxであるノードが見つかるまで、ツリーを上に移動します。
極端なケース：ノードが右端のコーナーノードである場合、順序付けられた後続ノードはありません。
これをJavaで行う
TreeNode getSuccessor(TreeNode treeNode) {
if (treeNode.right != null) {
return getLeftMostChild(treeNode.right);
} else {
TreeNode p = treeNode.parent;
while (p != null && treeNode == p.right) { // traverse upwards until there is no parent (at the last node of BST and when current treeNode is still the parent's right child
treeNode = p;
p = p.parent; // traverse upwards
}
return p; // returns the parent node
}
}
TreeNode getLeftMostChild(TreeNode treeNode) {
if (treeNode.left == null) {
return treeNode;
} else {
return getLeftMostChild(treeNode.left);
}
}