Optimum şekilde ikili arama ağacında k'inci en küçük elemanı bulun

Herhangi bir statik / global değişken kullanmadan ikili arama ağacında k'inci en küçük elemanı bulmam gerekiyor. Bunu verimli bir şekilde nasıl başarabilirim? Aklımdaki çözüm, tüm ağacın sıralı geçişini yapmayı planladığım için en kötü durum olan işlemi O (n) 'de yapmaktır. Ama derinlerde burada BST özelliğini kullanmadığımı hissediyorum. Varsayımsal çözümüm doğru mu yoksa daha iyi bir çözüm var mı?

İşte fikrin sadece bir özeti:

Bir BST'de, düğümün sol alt ağacı Tyalnızca içinde depolanan değerden daha küçük öğeler içerir T. Eğer ksol alt ağaç eleman sayısına, daha küçük ken küçük elemanı inci sol alt ağaç ait olmalıdır. Aksi takdirde, kdaha büyükse, o zaman en kküçük öğe sağ alt ağaçtadır.

BST'yi, içindeki her bir düğümün sol alt ağacındaki öğe sayısını depolaması için artırabiliriz (belirli bir düğümün sol alt ağacının bu düğümü içerdiğini varsayalım). Bu bilgi parçasıyla, sol alt ağaçta yineleme yapıp yapmayacağınıza karar vermek için, sol alt ağaçtaki öğelerin sayısını tekrar tekrar sorarak ağacı geçmek basittir.

Şimdi, T düğümünde olduğumuzu varsayalım:

1. Eğer (T alt ağacı sol) k == NUM_ELEMENTS , o zaman aradığınız cevap düğümünde değerdir T.
2. Eğer k> num_elements (T'nin sol alt ağacı) ise , sol alt ağacı görmezden gelebiliriz, çünkü bu elemanlar da ken küçüğünden daha küçük olacaktır. Böylece sorunu k - num_elements(left subtree of T)doğru alt ağacın en küçük öğesini bulmaya indirgiyoruz.
3. Eğer k <num_elements (T'nin sol alt ağacı) ise , o zaman en kküçük olan sol alt ağaçta bir yerdedir, bu nedenle sorunu ksoldaki alt ağaçtaki en küçük öğeyi bulmaya indirgiyoruz.

Karmaşıklık analizi:

Bu alan O(depth of node)olan zaman O(log n)dengeli bir BST'de veya en kötü durumda O(log n)rasgele BST için ortalama.

Bir BST, O(n)depolama gerektirir ve O(n)öğelerin sayısı hakkındaki bilgileri depolamak için bir tane daha gerekir. Tüm BST işlemleri O(depth of node)zaman alır O(depth of node)ve düğümlerin eklenmesi, silinmesi veya döndürülmesi için "öğe sayısı" bilgisini korumak ekstra zaman alır . Bu nedenle, sol alt ağaçtaki öğelerin sayısı hakkında bilgi depolamak, bir BST'nin uzay ve zaman karmaşıklığını korur.

Daha basit bir çözüm, sıralı bir geçiş yapmak ve o anda basılacak olan öğeyi takip etmek (yazdırmadan) olacaktır. K'ye ulaştığımızda, öğeyi yazdırın ve geri kalan ağaç geçişini atlayın.

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); 
}

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;
    }

bu, yukarıdaki algoritmaya dayanan C # uygulamamdır, sadece yayınlayacağımı düşündüm, böylece insanlar benim için daha iyi çalıştığını anlayabilir

teşekkür ederim IVlad

Daha basit bir çözüm, sıralı bir geçiş yapmak ve bir k sayacı ile o anda basılacak olan öğeyi takip etmek olacaktır. K'ye ulaştığımızda, elemanı yazdırın. Çalışma zamanı O (n). İşlev dönüş türünün geçersiz olamayacağını unutmayın, her özyinelemeli çağrıdan sonra güncellenmiş k değerini döndürmesi gerekir. Buna daha iyi bir çözüm, her düğümde sıralanmış bir konum değerine sahip artırılmış bir BST olacaktır.

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;
}

// özyinelemesiz bir java sürümü ekleyin

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();
        }
    }
}

Yinelemeli sıralı geçişi kullanabilirsiniz: http://en.wikipedia.org/wiki/Tree_traversal#Iterative_Traversal , yığından bir düğümü açtıktan sonra basit bir kth öğesi için kontrol ile.

Basit bir ikili arama ağacı verildiğinde, yapabileceğiniz tek şey en küçükten başlamak ve doğru düğümü bulmak için yukarı doğru hareket etmektir.

Bunu çok sık yapacaksanız, her bir düğüme, sol alt ağacında kaç düğüm olduğunu belirten bir öznitelik ekleyebilirsiniz. Bunu kullanarak, ağacı doğrudan doğru düğüme indirebilirsin.

Bir sayaç ile Özyinelemeli Sırayla Yürüyüş

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

Fikir @prasadvk çözümüne benzer, ancak bazı eksiklikleri var (aşağıdaki notlara bakın), bu yüzden bunu ayrı bir cevap olarak gönderiyorum.

// 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 );
}

Notlar (ve @ prasadvk çözümünden farklılıklar):

1. if( counter == k )Test üç yerde gereklidir : (a) sol alt ağaçtan sonra, (b) kökten sonra ve (c) sağ alt ağaçtan sonra. Bu, k'inci elemanın tüm konumlar için , yani bulunduğu alt ağaçtan bağımsız olarak tespit edilmesini sağlamak içindir .

2. if( result == -1 )test sadece sonuç öğesinin yazdırıldığından emin olmak için gereklidir , aksi takdirde k'inci en küçükten köke kadar tüm öğeler yazdırılır.

İçin değil ağacı aramaya dengeli, onu alır O (n) .

İçin Dengeli arama ağacının, onu alır O (k + log n) en kötü durumda ama sadece O (k) içinde Amortize anlamda.

Her düğüm için ekstra tam sayıya sahip olmak ve bunları yönetmek: alt ağacın boyutu O (log n) zaman karmaşıklığı verir. Bu tür dengeli arama ağacına genellikle RankTree denir.

Genelde çözümler var (ağaca dayalı değil).

Saygılarımızla.

Bu iyi çalışıyor: durum: elemanın bulunup bulunmadığını tutan dizidir. k: bulunacak k'inci elemandır. count: ağaç geçişi sırasında geçilen düğümlerin sayısını takip eder.

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;
}

Bu kesinlikle soruna en uygun çözüm olmasa da, bazı insanların ilginç bulabileceğini düşündüğüm başka bir olası çözüm:

/**
 * 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 );
}

imza:

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

şu şekilde ara:

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

tanım:

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;
}

İşte benim 2 sentim ...

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;
 }

Bu düşündüğüm şey ve işe yarıyor. O (log n) konumunda çalışacak

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

Peki, geçiş sırasına göre basitçe kullanabilir ve ziyaret edilen öğeyi bir yığının üzerine itebiliriz. cevabı almak için pop k sayısı kez.

k elementinden sonra da durabiliriz

Tam BST vakası için çözüm: -

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;
}

Linux Kernel, linux / lib / rbtree.c dosyasındaki O (log n) 'de sıra tabanlı işlemleri destekleyen mükemmel bir artırılmış kırmızı-siyah ağaç veri yapısına sahiptir.

Çok kaba bir Java bağlantı noktası http://code.google.com/p/refolding/source/browse/trunk/core/src/main/java/it/unibo/refolding/alg/RbTree.java adresinde de bulunabilir , RbRoot.java ve RbNode.java ile birlikte. N'inci eleman, ağacın kökünden geçerek RbNode.nth (RbNode düğümü, int n) çağırarak elde edilebilir.

Burada bir özlü versiyonu C # o döner k-inci en küçük elemanı, ancak bir ref argüman (o @prasadvk aynı yaklaşım) olarak k geçirerek gerektirir:

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);
}

En küçük düğümü bulmak için O (log n) ve sonra k-inci düğüme geçmek için O (k), yani O (k + log n).

http://www.geeksforgeeks.org/archives/10379

bu, bu sorunun tam cevabı: -

1. O (n) zamanında sıralı geçiş kullanarak 2. k + log n zamanında artırılmış ağaç kullanarak

Daha iyi bir algoritma bulamadım ... bu yüzden yazmaya karar verdim :) Yanlışsa beni düzeltin.

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));
}

}

İşte java kodu,

max (Düğüm kökü, int k) - en büyük kinci bulmak için

min (Düğüm kökü, int k) - kth En Küçük'ü bulmak için

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);
}

bu da işe yarar. sadece ağaçta maxNode ile işlevi çağırın

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)

Bunun kabul edilen cevaptan daha iyi olduğunu düşünüyorum çünkü alt düğümlerinin sayısını depolamak için orijinal ağaç düğümünü değiştirmeye gerek yok.

Soldan sağa en küçük düğümü saymak için sıralı geçişi kullanmalıyız, sayı K'ye eşit olduğunda aramayı durdurmalıyız.

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);
}

En iyi yaklaşım zaten mevcut, ancak bunun için basit bir Kod eklemek istiyorum

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 );
}}

Düğüm bulunup bulunmadığını ve k geçerli olup olmadığını izlemek için yardımcı Sonuç sınıfını kullanma.

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;
    }
}
}

Python Çözümü Zaman Karmaşıklığı: O (n) Uzay Karmaşıklığı: O (1)

Fikir, Morris Inorder Traversal'ı kullanmaktır

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  )

k'inci en küçük elemanı hesaplamak için düzgün bir fonksiyon yazdım. Sıralı geçişi kullanıyorum ve k'inci en küçük elemana ulaştığında duruyorum.

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);  }}

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;
}

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;
    }
}

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;

      }
  }

}