kd树迭代非基于堆栈的插入

问题描述

我正在寻找仅基于迭代的非堆栈（由于内存限制和最小的重构）的kd树插入。

我有一个完整的kd-tree库，使用C语言工作，函数（插入，读取，更新，删除，knn搜索，重新平衡）开始用迭代函数替换所有递归函数。

但是，我注意到我的插入不适用于某些测试数据。这意味着实际上在使用迭代实现时搜索找不到插入的节点，但是在使用递归实现时找到了所有数据，因此，该错误位于迭代插入版本中。

节点结构：

typedef struct kd_tree_node
{  
    struct kd_tree_node* left; 
    struct kd_tree_node* right; 
    struct kd_tree_node* parent; 
    float* dataset;  
    float distance_to_neighbor;
} kd_tree_node;

下面是一个迭代插入（我包括直接相关的部分。没有重新平衡逻辑，等等...）：

void
kd_tree_add_record(kd_tree_node* root,const float data [],int depth,const int k_dimensions,const int copying,const float rebuild_threshold) {

   /*rebalancing logic is NOT relevant,which  I have NOT include,we can just build inefficient tree*/
    
    /* is root empty? */
    if (is_empty_node(root,k_dimensions)) {
        root = kd_tree_new_node(data,k_dimensions,copying);
        /*was the root set before*/
        if (is_empty_node(kd_tree_get_root(),k_dimensions)) {
            kd_tree_set_root(root);
        }
    } else {
        /*iteratively insert new node*/
        current = kd_tree_get_root();
        /*while current is NOT null*/
        while (!is_empty_node(current,k_dimensions)) {
            parent = current;
            /* Calculate current dimension (cd) of comparison */
            cd = depth % k_dimensions;
            /*determine current dimension/*/
            /*by using modula operator we can cycle through all dimensions */
            /* and decide the left or right subtree*/
            median = kd_tree_get_column_median(cd);
            //printf("kd_tree_add_record.(),median=%f\n",median);
            if (data[cd] < median) {
              current = current->left; 
               
            } else {
                current = current->right;
                
            }
            depth++;
        }//end while
        
        /*should be inserted left or right of the parent*/
        int insert_left = 1; 
        depth = 0;  
        if (!is_empty_node(parent,k_dimensions)) {
            int c = 0;
            for (; c < k_dimensions; c++) {
            
            cd = depth % k_dimensions;
            median = kd_tree_get_column_median(cd);
                if (parent->dataset[cd] < median) {
                   
                } else {
                     insert_left = 0;
                     break; 
                   
                }
            depth++;
            }
            
            if (insert_left)
            {
                 parent->left = kd_tree_new_node(data,copying);
                 
            }
            else
            {
                 parent->right = kd_tree_new_node(data,copying);
                 
            }
        }
        
    }//end else

}

我通过尝试遵循以下代码中的迭代二叉树插入C ++代码，来基于上述kd-tree插入迭代代码：（https://www.techiedelight.com/insertion-in-bst/），可以在线对其进行测试，请参见下文（请注意，这不是我的代码及其提供的参考）：

void insertIterative(Node*& root,int key)
{
    // start with root node
    Node *curr = root;

    // pointer to store parent node of current node
    Node *parent = nullptr;

    // if tree is empty,create a new node and set root
    if (root == nullptr)
    {
        root = newNode(key);
        return;
    }

    // traverse the tree and find parent node of key
    while (curr != nullptr)
    {
        // update parent node as current node
        parent = curr;

        // if given key is less than the current node,go to left subtree
        // else go to right subtree
        if (key < curr->data)
            curr = curr->left;
        else
            curr = curr->right;
    }

    // construct a new node and assign to appropriate parent pointer
    if (key < parent->data)
        parent->left = newNode(key);
    else
        parent->right = newNode(key);
}

这是我以前的kd-tree递归插入版本，该版本有效：

   kd_tree_node *
  kd_tree_add_record(kd_tree_node * root,const float data[],const float rebuild_threshold) {
    float median = 0.0;
    /* Tree is empty? */
    if (NULL == root || NULL == root -> dataset || is_empty_node(root,k_dimensions)) {

      root = kd_tree_new_node(data,copying);

      //update the root globally
      if (kd_tree_get_root() == NULL) {
        kd_tree_set_root(root);
      }

    } else {

      /* Calculate current dimension (cd) of comparison */
      size_t cd = depth % k_dimensions;
      /*determine current dimension/*/
      /*by using modula operator we can cycle through all dimensions */

      /* and decide the left or right subtree*/
      median = kd_tree_get_column_median(cd);

      if (data[cd] < median) {

        root -> left = kd_tree_add_record(root -> left,data,depth + 1,copying,rebuild_threshold);
      } else {

        root -> right = kd_tree_add_record(root -> right,rebuild_threshold);
      }
    } //end else
    return root;

  } 

当前测试结果：

-53.148998,0.000000,9.000000 Found
 7.999700,0.069812,8.000000 Found
 7.998780,0.139619,8.000000 Found
 7.997260,0.209416,8.000000 Not Found!
7.995130,0.279196,8.000000 Not Found!
 7.992390,0.348955,8.000000 Not Found!
8.987670,0.471024,9.000000 Found
8.983210,0.549437,9.000000 Found
 7.980510,0.558052,8.000000 Not Found!
 3.000000,3.000000,3.000000 Found
4.000000,4.000000,4.000000 Found
5.000000,5.000000,5.000000 Found!
100.000000,100.000000,100.000000 Found

如何将迭代非堆栈二进制插入算法扩展到kd树？

非常感谢！

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）