最適な方法で二分探索木のk番目に小さい要素を見つける


112

静的/グローバル変数を使用せずに、バイナリ検索ツリーでk番目に小さい要素を見つける必要があります。それを効率的に達成する方法は?私が心に留めている解決策は、O(n)で操作を実行することです。これは、ツリー全体を順不同に走査することを計画しているため、最悪のケースです。しかし、ここのBSTプロパティは使用していないようです。私の仮定の解決策は正しいですか、それともより良い解決策がありますか?


7
木はバランスが取れていますか?
kennytm

そうではありません。しかし、バランスが取れている場合、最適な方法はありますか?
ブラッグボーイ、2010

1
「注文統計」を検索すると、必要なものが見つかります。
RAL

私は以下の答えのほとんどを感じていますが、正しいのは、ある種のグローバル変数を使用しているという点でだまされています(整数への参照か、デクリメントされて返される変数か)。これらの一切が許可されていない場合、私は、渡されるすべての参照せずに再帰を使用します。
ヘンリーチウ

回答:


170

アイデアの概要は次のとおりです。

BSTでは、ノードの左側のサブツリーにTは、に格納されている値より小さい要素のみが含まれていTます。kが左側のサブツリーの要素数よりも小さい場合、k3番目に小さい要素が左側のサブツリーに属している必要があります。それ以外の場合は、kが大きい場合、k最小の要素は右のサブツリーにあります。

BSTを拡張して、その中の各ノードに左サブツリーの要素の数を格納させることができます(特定のノードの左サブツリーにそのノードが含まれていると想定します)。この情報があれば、左サブツリーの要素数を繰り返し尋ねることでツリーをたどり、左サブツリーに再帰するか右サブツリーに再帰するかを決定するのは簡単です。

ここで、ノードTにいるとします。

  1. もしK == NUM_ELEMENTS(Tの左部分木)、そして私たちが探している答えは、ノードの値ですT
  2. 場合K> NUM_ELEMENTS(Tの左サブツリー)それらの要素もより小さくなるので、その後明らかに、我々は、左のサブツリーを無視することができk番目に小さいです。したがって、問題を減らしてk - num_elements(left subtree of T)、正しいサブツリーの最小要素を見つけます。
  3. もしK <NUM_ELEMENTS(Tの左サブツリー)、その後、k我々は発見に問題を低減するように番目に小さいが、左サブツリー内のどこかにあるk左サブツリー内番目に小さい要素。

複雑さの分析:

これにはO(depth of node)時間がかかります。これはO(log n)、バランスのとれたBSTでは最悪の場合O(log n)、ランダムBSTでは平均です。

BSTにはO(n)ストレージが必要でありO(n)、要素数に関する情報を格納するには別のものが必要です。すべてのBST操作にはO(depth of node)時間がかかりO(depth of node)、ノードの挿入、削除、または回転に関する「要素数」情報を維持するのに余分な時間がかかります。したがって、左側のサブツリーの要素数に関する情報を格納すると、BSTの空間と時間の複雑さが維持されます。


59
N番目に小さいアイテムを見つけるには、左側のサブツリーのサイズを格納するだけです。N番目に大きいアイテムを見つけられるようにしたい場合は、正しいサブツリーのサイズを使用します。実際には、それをより安価にすることもできます。ルートのツリーの合計サイズと左側のサブツリーのサイズを格納します。右側のサブツリーのサイズを変更する必要がある場合は、合計サイズから左側のサイズを差し引くことができます。
Jerry Coffin

37
このように拡張されたBSTは、「注文統計ツリー」と呼ばれます。
Daniel

10
@Ivlad:ステップ2では、ルート要素も含める必要があるので、「k-num_elements」は「k-num_elements -1」になるはずです。
understack

1
@understack-ルートがサブツリーの一部であると想定する場合は除きます。
IVlad

16
「左と右のサブツリーの要素数」を含むフィールドがツリーに含まれていない場合、メソッドは各ノードで右または左のサブツリーを歩く必要があるため、BigO(n)になります。現在のノードのkインデックスを計算します。
ロバートS.バーンズ

68

より簡単な解決策は、順序付けトラバーサルを実行し、現在印刷されている要素を(印刷せずに)追跡することです。kに達したら、要素を出力し、ツリーの全探索をスキップします。

void findK(Node* p, int* k) {
  if(!p || k < 0) return;
  findK(p->left, k);
  --k;
  if(k == 0) { 
    print p->data;
    return;  
  } 
  findK(p->right, k); 
}

1
+1:アイデアは正しい方向にありますが、一部のルーズエンドを引き締める必要がある場合があります。stackoverflow.com/a/23069077/278326を
アルン、

1
私はこのソリューションが好きです。BSTはすでに注文されているため、トラバーサルで十分です。
マーリン2015年

3
nがこのツリーのノードの総数に近い場合、アルゴリズムは終了するのにO(n)時間かかります。これは、選択された回答O(log n)に
適さない

13
public int ReturnKthSmallestElement1(int k)
    {
        Node node = Root;

        int count = k;

        int sizeOfLeftSubtree = 0;

        while(node != null)
        {

            sizeOfLeftSubtree = node.SizeOfLeftSubtree();

            if (sizeOfLeftSubtree + 1 == count)
                return node.Value;
            else if (sizeOfLeftSubtree < count)
            {
                node = node.Right;
                count -= sizeOfLeftSubtree+1;
            }
            else
            {
                node = node.Left;
            }
        }

        return -1;
    }

これは、上記のアルゴリズムに基づくC#での私の実装です。人々がそれが私のために機能することをよりよく理解できるように、私がそれを投稿すると思っていました

IVladありがとう


11

より簡単な解決策は、順序トラバーサルを行い、現在印刷されている要素をカウンターkで追跡することです。kに達したら、要素を出力します。ランタイムはO(n)です。関数の戻り値の型を無効にすることはできません。再帰呼び出しのたびに、更新されたkの値を返す必要があります。これに対するより良い解決策は、各ノードでソートされた位置値を持つ拡張BSTです。

public static int kthSmallest (Node pivot, int k){
    if(pivot == null )
        return k;   
    k = kthSmallest(pivot.left, k);
    k--;
    if(k == 0){
        System.out.println(pivot.value);
    }
    k = kthSmallest(pivot.right, k);
    return k;
}

拡張されたBSTと比較して、スペースの複雑さの点でソリューションが優れていると思います。
zach

k番目に小さい要素が見つかった後も、検索は停止しません。
Vineeth Chitteti

10

//再帰なしでJavaバージョンを追加します

public static <T> void find(TreeNode<T> node, int num){
    Stack<TreeNode<T>> stack = new Stack<TreeNode<T>>();

    TreeNode<T> current = node;
    int tmp = num;

    while(stack.size() > 0 || current!=null){
        if(current!= null){
            stack.add(current);
            current = current.getLeft();
        }else{
            current = stack.pop();
            tmp--;

            if(tmp == 0){
                System.out.println(current.getValue());
                return;
            }

            current = current.getRight();
        }
    }
}

私はこのソリューションとそれに対応する再帰的なソリューションが好きです。正直なところ、この質問に対する回答のほとんどは、複雑すぎて複雑すぎて読めません。
Henley Chiu 2013

このソリューションが大好きです。クリアで素晴らしい!
Rugal

このソリューションは、ツリーを「順序どおりに」トラバースし、ノードにアクセスした後にカウンターを減らし、後でカウンターがゼロになったときに停止します。その場合、最悪のケースはO(n)のオーダーになります。最悪の場合にO(log n)をとる@IVladの再帰的ソリューションと比較して最適ではありません
Jorge P.


4

単純な二分探索木だけを考えると、できることは、最小のものから始めて、上にトラバースして正しいノードを見つけることです。

これを頻繁に行う場合は、左側のサブツリーにノードがいくつあるかを示す属性を各ノードに追加できます。これを使用して、ツリーを直接正しいノードに降りることができます。


4

カウンター付きの再帰的順序ウォーク

Time Complexity: O( N ), N is the number of nodes
Space Complexity: O( 1 ), excluding the function call stack

アイデアは@prasadvkソリューションに似ていますが、いくつかの欠点があるため(以下の注を参照)、これを別の回答として投稿しています。

// Private Helper Macro
#define testAndReturn( k, counter, result )                         \
    do { if( (counter == k) && (result == -1) ) {                   \
        result = pn->key_;                                          \
        return;                                                     \
    } } while( 0 )

// Private Helper Function
static void findKthSmallest(
    BstNode const * pn, int const k, int & counter, int & result ) {

    if( ! pn ) return;

    findKthSmallest( pn->left_, k, counter, result );
    testAndReturn( k, counter, result );

    counter += 1;
    testAndReturn( k, counter, result );

    findKthSmallest( pn->right_, k, counter, result );
    testAndReturn( k, counter, result );
}

// Public API function
void findKthSmallest( Bst const * pt, int const k ) {
    int counter = 0;
    int result = -1;        // -1 := not found
    findKthSmallest( pt->root_, k, counter, result );
    printf("%d-th element: element = %d\n", k, result );
}

注意(および@prasadvkのソリューションとの違い):

  1. if( counter == k )テストは、(a)左サブツリーの後、(b)ルートの後、および(c)右サブツリーの後の3つの場所で必要です。これは、k番目の要素がすべての場所確実に検出されるようにするためです。つまり、要素が配置されているサブツリーに関係なく、

  2. if( result == -1 )結果要素のみが出力されることを確認するために必要なテスト。それ以外の場合は、k番目に小さい要素からルートまでのすべての要素が出力されます。


このソリューションの時間の複雑さはO(k + d)であり、dはツリーの最大深度です。したがって、グローバル変数を使用しますcounterが、この質問には違法です。
Valentin Shergin 2014

こんにちはアルン、例を挙げて説明してください。私はこれ、特にあなたの最初の点を理解していません。
Andy897 2015年

3

以下のためではないバランスのとれた検索ツリーは、かかるO(n)を

以下のためにバランスのとれた検索ツリーは、かかるO(K + Nログ)最悪の場合が、わずかにO(K)償却センス。

ノードごとに追加の整数を用意して管理する:サブツリーのサイズにより、O(log n)の時間が複雑になります。このようなバランスのとれた検索ツリーは通常、RankTreeと呼ばれます。

一般に、解決策はあります(ツリーに基づかない)。

よろしく。


1

これはうまくいきます:status:要素が見つかったかどうかを保持する配列です。k:検出されるk番目の要素です。count:ツリーのトラバース中にトラバースされたノードの数を追跡します。

int kth(struct tree* node, int* status, int k, int count)
{
    if (!node) return count;
    count = kth(node->lft, status, k, count);  
    if( status[1] ) return status[0];
    if (count == k) { 
        status[0] = node->val;
        status[1] = 1;
        return status[0];
    }
    count = kth(node->rgt, status, k, count+1);
    if( status[1] ) return status[0];
    return count;
}

1

これは間違いなく問題の最適な解決策ではありませんが、一部の人々が興味深いと思う可能性のある別の解決策です。

/**
 * Treat the bst as a sorted list in descending order and find the element 
 * in position k.
 *
 * Time complexity BigO ( n^2 )
 *
 * 2n + sum( 1 * n/2 + 2 * n/4 + ... ( 2^n-1) * n/n ) = 
 * 2n + sigma a=1 to n ( (2^(a-1)) * n / 2^a ) = 2n + n(n-1)/4
 *
 * @param t The root of the binary search tree.
 * @param k The position of the element to find.
 * @return The value of the element at position k.
 */
public static int kElement2( Node t, int k ) {
    int treeSize = sizeOfTree( t );

    return kElement2( t, k, treeSize, 0 ).intValue();
}

/**
 * Find the value at position k in the bst by doing an in-order traversal 
 * of the tree and mapping the ascending order index to the descending order 
 * index.
 *
 *
 * @param t Root of the bst to search in.
 * @param k Index of the element being searched for.
 * @param treeSize Size of the entire bst.
 * @param count The number of node already visited.
 * @return Either the value of the kth node, or Double.POSITIVE_INFINITY if 
 *         not found in this sub-tree.
 */
private static Double kElement2( Node t, int k, int treeSize, int count ) {
    // Double.POSITIVE_INFINITY is a marker value indicating that the kth 
    // element wasn't found in this sub-tree.
    if ( t == null )
        return Double.POSITIVE_INFINITY;

    Double kea = kElement2( t.getLeftSon(), k, treeSize, count );

    if ( kea != Double.POSITIVE_INFINITY )
        return kea;

    // The index of the current node.
    count += 1 + sizeOfTree( t.getLeftSon() );

    // Given any index from the ascending in order traversal of the bst, 
    // treeSize + 1 - index gives the
    // corresponding index in the descending order list.
    if ( ( treeSize + 1 - count ) == k )
        return (double)t.getNumber();

    return kElement2( t.getRightSon(), k, treeSize, count );
}

1

署名:

Node * find(Node* tree, int *n, int k);

として呼び出す:

*n = 0;
kthNode = find(root, n, k);

定義:

Node * find ( Node * tree, int *n, int k)
{
   Node *temp = NULL;

   if (tree->left && *n<k)
      temp = find(tree->left, n, k);

   *n++;

   if(*n==k)
      temp = root;

   if (tree->right && *n<k)
      temp = find(tree->right, n, k);

   return temp;
}

1

さてここに私の2セントです...

int numBSTnodes(const Node* pNode){
     if(pNode == NULL) return 0;
     return (numBSTnodes(pNode->left)+numBSTnodes(pNode->right)+1);
}


//This function will find Kth smallest element
Node* findKthSmallestBSTelement(Node* root, int k){
     Node* pTrav = root;
     while(k > 0){
         int numNodes = numBSTnodes(pTrav->left);
         if(numNodes >= k){
              pTrav = pTrav->left;
         }
         else{
              //subtract left tree nodes and root count from 'k'
              k -= (numBSTnodes(pTrav->left) + 1);
              if(k == 0) return pTrav;
              pTrav = pTrav->right;
        }

        return NULL;
 }

0

これは私が思っていることで、うまくいきます。o(log n)で実行されます

public static int FindkThSmallestElemet(Node root, int k)
    {
        int count = 0;
        Node current = root;

        while (current != null)
        {
            count++;
            current = current.left;
        }
        current = root;

        while (current != null)
        {
            if (count == k)
                return current.data;
            else
            {
                current = current.left;
                count--;
            }
        }

        return -1;


    } // end of function FindkThSmallestElemet

3
私はこの解決策がうまくいくとは思いません。K番目に小さいものがツリーノードの右側のサブツリーにある場合はどうなりますか?
Anil Vishnoi

0

さて、順序トラバーサルを使用して、アクセスした要素をスタックにプッシュできます。答えを得るためにk回ポップします。

k要素の後で停止することもできます


1
これは最適なソリューションではありません
ブラッグボーイ、2011

0

完全なBSTケースのソリューション:-

Node kSmallest(Node root, int k) {
  int i = root.size(); // 2^height - 1, single node is height = 1;
  Node result = root;
  while (i - 1 > k) {
    i = (i-1)/2;  // size of left subtree
    if (k < i) {
      result = result.left;
    } else {
      result = result.right;
      k -= i;
    }  
  }
  return i-1==k ? result: null;
}

0

Linuxカーネルは、linux / lib / rbtree.cのO(log n)でランクベースの操作をサポートする、優れた拡張された赤黒ツリーデータ構造を備えています。

非常に粗雑なJavaポートはhttp://code.google.com/p/refolding/source/browse/trunk/core/src/main/java/it/unibo/refolding/alg/RbTree.javaにもあります。 RbRoot.javaおよびRbNode.javaとともに。n番目の要素は、RbNode.nth(RbNode node、int n)を呼び出して、ツリーのルートを渡すことで取得できます。


0

これ、k番目に小さい要素を返すC#の簡潔なバージョンです、ref引数としてkを渡す必要があります(@prasadvkと同じアプローチです)。

Node FindSmall(Node root, ref int k)
{
    if (root == null || k < 1)
        return null;

    Node node = FindSmall(root.LeftChild, ref k);
    if (node != null)
        return node;

    if (--k == 0)
        return node ?? root;
    return FindSmall(root.RightChild, ref k);
}

それは見つけるために(Nログ)Oだ最小のノードを、そしてそれはO(K + Nログ)ですので、次に、O(k)は、k番目のノードまでトラバースします。


Javaバージョンはどうですか?
Henley Chiu 2013


0

私はより良いアルゴリズムを見つけることができませんでした。

class KthLargestBST{
protected static int findKthSmallest(BSTNode root,int k){//user calls this function
    int [] result=findKthSmallest(root,k,0);//I call another function inside
    return result[1];
}
private static int[] findKthSmallest(BSTNode root,int k,int count){//returns result[]2 array containing count in rval[0] and desired element in rval[1] position.
    if(root==null){
        int[]  i=new int[2];
        i[0]=-1;
        i[1]=-1;
        return i;
    }else{
        int rval[]=new int[2];
        int temp[]=new int[2];
        rval=findKthSmallest(root.leftChild,k,count);
        if(rval[0]!=-1){
            count=rval[0];
        }
        count++;
        if(count==k){
            rval[1]=root.data;
        }
        temp=findKthSmallest(root.rightChild,k,(count));
        if(temp[0]!=-1){
            count=temp[0];
        }
        if(temp[1]!=-1){
            rval[1]=temp[1];
        }
        rval[0]=count;
        return rval;
    }
}
public static void main(String args[]){
    BinarySearchTree bst=new BinarySearchTree();
    bst.insert(6);
    bst.insert(8);
    bst.insert(7);
    bst.insert(4);
    bst.insert(3);
    bst.insert(4);
    bst.insert(1);
    bst.insert(12);
    bst.insert(18);
    bst.insert(15);
    bst.insert(16);
    bst.inOrderTraversal();
    System.out.println();
    System.out.println(findKthSmallest(bst.root,11));
}

}


0

これがJavaコードです、

max(Node root、int k)-k番目に大きいものを見つける

min(Node root、int k)-k番目に小さいものを見つける

static int count(Node root){
    if(root == null)
        return 0;
    else
        return count(root.left) + count(root.right) +1;
}
static int max(Node root, int k) {
    if(root == null)
        return -1;
    int right= count(root.right);

    if(k == right+1)
        return root.data;
    else if(right < k)
        return max(root.left, k-right-1);
    else return max(root.right, k);
}

static int min(Node root, int k) {
    if (root==null)
        return -1;

    int left= count(root.left);
    if(k == left+1)
        return root.data;
    else if (left < k)
        return min(root.right, k-left-1);
    else
        return min(root.left, k);
}

0

これも機能します。ツリーのmaxNodeで関数を呼び出すだけです

def k_largest(self、node、k):if k <0:return None
if k == 0:return node else:k-= 1 return self.k_largest(self.predecessor(node)、k)


0

子ノードの数を格納するために元のツリーノードを変更する必要がないため、これは受け入れられた回答よりも優れていると思います。

順序トラバーサルを使用して最小のノードを左から右にカウントし、カウントがKになったら検索を停止するだけです。

private static int count = 0;
public static void printKthSmallestNode(Node node, int k){
    if(node == null){
        return;
    }

    if( node.getLeftNode() != null ){
        printKthSmallestNode(node.getLeftNode(), k);
    }

    count ++ ;
    if(count <= k )
        System.out.println(node.getValue() + ", count=" + count + ", k=" + k);

    if(count < k  && node.getRightNode() != null)
        printKthSmallestNode(node.getRightNode(), k);
}

0

最良のアプローチはすでにありますが、そのための簡単なコードを追加したいと思います

int kthsmallest(treenode *q,int k){
int n = size(q->left) + 1;
if(n==k){
    return q->val;
}
if(n > k){
    return kthsmallest(q->left,k);
}
if(n < k){
    return kthsmallest(q->right,k - n);
}

}

int size(treenode *q){
if(q==NULL){
    return 0;
}
else{
    return ( size(q->left) + size(q->right) + 1 );
}}

0

補助Resultクラスを使用して、ノードが見つかったかどうか、および現在のkを追跡します。

public class KthSmallestElementWithAux {

public int kthsmallest(TreeNode a, int k) {
    TreeNode ans = kthsmallestRec(a, k).node;
    if (ans != null) {
        return ans.val;
    } else {
        return -1;
    }
}

private Result kthsmallestRec(TreeNode a, int k) {
    //Leaf node, do nothing and return
    if (a == null) {
        return new Result(k, null);
    }

    //Search left first
    Result leftSearch = kthsmallestRec(a.left, k);

    //We are done, no need to check right.
    if (leftSearch.node != null) {
        return leftSearch;
    }

    //Consider number of nodes found to the left
    k = leftSearch.k;

    //Check if current root is the solution before going right
    k--;
    if (k == 0) {
        return new Result(k - 1, a);
    }

    //Check right
    Result rightBalanced = kthsmallestRec(a.right, k);

    //Consider all nodes found to the right
    k = rightBalanced.k;

    if (rightBalanced.node != null) {
        return rightBalanced;
    }

    //No node found, recursion will continue at the higher level
    return new Result(k, null);

}

private class Result {
    private final int k;
    private final TreeNode node;

    Result(int max, TreeNode node) {
        this.k = max;
        this.node = node;
    }
}
}

0

Pythonソリューションの時間の複雑さ:O(n)空間の複雑さ:O(1)

アイデアはMorris Inorder Traversalを使用することです

class Solution(object):
def inorderTraversal(self, current , k ):
    while(current is not None):    #This Means we have reached Right Most Node i.e end of LDR traversal

        if(current.left is not None):  #If Left Exists traverse Left First
            pre = current.left   #Goal is to find the node which will be just before the current node i.e predecessor of current node, let's say current is D in LDR goal is to find L here
            while(pre.right is not None and pre.right != current ): #Find predecesor here
                pre = pre.right
            if(pre.right is None):  #In this case predecessor is found , now link this predecessor to current so that there is a path and current is not lost
                pre.right = current
                current = current.left
            else:                   #This means we have traverse all nodes left to current so in LDR traversal of L is done
                k -= 1
                if(k == 0):
                    return current.val
                pre.right = None       #Remove the link tree restored to original here 
                current = current.right
        else:               #In LDR  LD traversal is done move to R 
            k -= 1
            if(k == 0):
                return current.val
            current = current.right

    return 0

def kthSmallest(self, root, k):
    return self.inorderTraversal( root , k  )

-1

私はk番目に小さい要素を計算するためのきちんとした関数を書きました。私は順序トラバーサルを使用し、それがk番目に小さい要素に到達したときに停止します。

void btree::kthSmallest(node* temp, int& k){
if( temp!= NULL)   {
 kthSmallest(temp->left,k);       
 if(k >0)
 {
     if(k==1)
    {
      cout<<temp->value<<endl;
      return;
    }

    k--;
 }

 kthSmallest(temp->right,k);  }}

これがなぜ最適なのかについての指標は提供されていません。両方の大小のケースで
Woot4Moo

-1
int RecPrintKSmallest(Node_ptr head,int k){
  if(head!=NULL){
    k=RecPrintKSmallest(head->left,k);
    if(k>0){
      printf("%c ",head->Node_key.key);
      k--;
    }
    k=RecPrintKSmallest(head->right,k);
  }
  return k;
}

2
コードの機能と問題の解決に役立つ方法については、常にある程度の説明をコードに添えてください。
Ren

-1
public TreeNode findKthElement(TreeNode root, int k){
    if((k==numberElement(root.left)+1)){
        return root;
    }
    else if(k>numberElement(root.left)+1){
        findKthElement(root.right,k-numberElement(root.left)-1);
    }
    else{
        findKthElement(root.left, k);
    }
}

public int numberElement(TreeNode node){
    if(node==null){
        return 0;
    }
    else{
        return numberElement(node.left) + numberElement(node.right) + 1;
    }
}

-1
public static Node kth(Node n, int k){
    Stack<Node> s=new Stack<Node>();
    int countPopped=0;
    while(!s.isEmpty()||n!=null){
      if(n!=null){
        s.push(n);
        n=n.left;
      }else{
        node=s.pop();
        countPopped++;
        if(countPopped==k){
            return node;
        }
        node=node.right;

      }
  }

}

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.