±±¾©Ê¯ÓÍ»¯¹¤Ñ§Ôº2026ÄêÑо¿ÉúÕÐÉú½ÓÊÕµ÷¼Á¹«¸æ
²é¿´: 1284  |  »Ø¸´: 4

lxb9721

гæ (ÕýʽдÊÖ)

[ÇóÖú] Çó¸ßÊÖ°ïæÐÞ¸ÄÒ»¶Îc++³ÌÐò

ÏÂÃæÊÇÒ»¶Î½¨Á¢K-DÊ÷µÄc++³ÌÐò£¬ÆäÖгÌÐòÖеÄÊý¾ÝÒªÐÞ¸ÄΪÓöÁÈëtxtÎļþÖеÄÊý¾ÝÀ´±íʾ£¬ÇÒtxtÎļþÖеÄÊý¾ÝΪÈýÁУ¬ÒÔ¿Õ¸ñ·Ö¸î¡£
main.cpp

#include "3dtree.h"

#include
#include

void main()
{
        time_t tt = time(NULL);

        //½¨Á¢Ê÷
        int nodes = 100000;
        kdTree t(nodes);

        //´æ´¢Êý¾Ý
        t.store(1.0,1.0,1.0,0);
        t.store(1.0,2.0,1.0,1);
        t.store(2.0,4.0,5.0,2);
        t.store(3.0,1.0,2.0,3);
        t.store(4.0,6.0,2.0,4);
        t.store(1.0,5.0,8.0,5);
        //µ÷ÕûÊ÷
        t.treeBalance();
        //ѰÕÒ×î½üÁÙµã
        nNearestNodes nNN(3);
        nNN.setDistandIndx(4.3);
        nNN.setSearchPnt(2.0,4.0,5.0);

        cout << endl << "searching ..." << endl;
        t.locateNodes(&nNN,1);

        if(nNN.found)
                for(int i = 1; i <= nNN.found; i++)
                {
                        cout < < "id of the nearest point: " << nNN.index->id < < endl < <
                                "the dis: " < < nNN.dist2 << endl;
                       
                        cout < < "the coordinates of the point:";
                        cout < < nNN.index->pos[0] < < " "
                                < < nNN.index->pos[1] < < " "
                                < < nNN.index->pos[2] < < endl < < endl;
                }
        else
                cout << "Nothing found!" << endl << endl;
       
        cout<<"run time:"<
        system("pause";
}

3dtree.cpp

#include "3dtree.h"

kdTree::kdTree(const int nodes)
{
        storedKDNodes = 0;
        maxNumOfNodes = nodes;

        kdNodes = new kdNode[maxNumOfNodes + 1];
        if(!kdNodes)
        {
                cout<<"³õʼ»¯kdÊ÷ʱÄÚ´æÒç³ö£¡"<                 exit(-1);
        }

        boundrayMin[0] = boundrayMin[1] = boundrayMin[2] = 1e8f;
        boundrayMax[0] = boundrayMax[1] = boundrayMax[2] = -1e8f;
}

kdTree::~kdTree()
{
        delete [] kdNodes;
}

void kdTree::treeBalance()
{
        if(storedKDNodes > 1)
        {
                kdNode **pa1 = new kdNode*[storedKDNodes + 1];  //×éÖ¯ºÃÊ÷ºóµÄÖ¸Õë
                kdNode **pa2 = new kdNode*[storedKDNodes + 1];  //Ô­Ê¼ÔªËØµÄÖ¸Õë

                for(int i =0; i <= storedKDNodes; i++)
                        pa2 = &kdNodes;

                balancePartition(pa1, pa2, 1, 1, storedKDNodes);
                delete []pa2;

                //ÖØÐÂÅÅÁÐÊ÷
                //__w64 int d, j = 1;                  // According to the warning given when 'int ' is used
                int d, j = 1; //jλÖÃÔªËØÒѾ­×ªÒÆ×ß
                int foo = 1;  //fooNodes´æ´¢µÄÔªËØµÄ×î³õλÖÃ
                kdNode fooNodes = kdNodes[j];

                for( int i = 1; i <= storedKDNodes; i++)
                {
                        d = pa1[j] - kdNodes;
                        pa1[j] = NULL;

                        if(d != foo)
                                kdNodes[j] = kdNodes[d];
                        else
                        {
                                kdNodes[j] = fooNodes;

                                if(i < storedKDNodes)
                                {
                                        for(; foo <= storedKDNodes; foo++)
                                                if(NULL != pa1[foo])
                                                        break;

                                        fooNodes = kdNodes[foo];
                                        j = foo;
                                }
                                continue;
                        }
                        j = d;
                }
                delete []pa1;
        }
        halfStoredKDNodes = storedKDNodes/2 - 1;
}

void kdTree::locateNodes(nNearestNodes * const nNN,const int index)const
{
        const kdNode *p = &kdNodes[index];
        double dist1;

        if(index < halfStoredKDNodes)
        {
                dist1 = nNN->pos[p->plane] - p->pos[p->plane];

                if(0.0 < dist1)
                {
                        locateNodes(nNN, 2 * index + 1);
                        if(nNN->dist2[0] > dist1 * dist1)
                                locateNodes(nNN, 2 * index);
                }
                else
                {
                        locateNodes(nNN, 2 * index);
                        if(nNN->dist2[0] > dist1 * dist1)
                                locateNodes(nNN, 2 * index + 1);
                }//if
        }//if

        // ¼ÆËã¾àÀë
        dist1 = p->pos[0] - nNN->pos[0];
        double dist2 = dist1 * dist1;
        dist1 = p->pos[1] - nNN->pos[1];
        dist2 += dist1 * dist1;
        dist1 = p->pos[2] - nNN->pos[2];
        dist2 += dist1 * dist1;

        if(nNN->dist2[0] > dist2)
        {
                if(nNN->found < nNN->max)
                {
                        nNN->found++;
                        nNN->dist2[nNN->found] = dist2;
                        nNN->index[nNN->found] = p;
                }
                else
                {
                        int j, parent;
                        if(0 == nNN->got_Heap)//½¨Á¢´ó¶¥¶Ñ
                        {
                                double dst2;
                                const kdNode *nd;
                                int halfFound = nNN->found >> 1;

                                for(int k = halfFound; k >= 1; k--)
                                {
                                        parent = k;
                                        nd = nNN->index[k];
                                        dst2 = nNN->dist2[k];

                                        while(parent <= halfFound)
                                        {
                                                j = parent + parent;

                                                if(j < nNN->found && nNN->dist2[j] < nNN->dist2[j + 1])
                                                        j ++;

                                                if(dst2 >= nNN->dist2[j])
                                                        break;

                                                nNN->dist2[parent] = nNN->dist2[j];
                                                nNN->index[parent] = nNN->index[j];

                                                parent = j;
                                        }//while
                                        nNN->dist2[parent] = dst2;
                                        nNN->index[parent] = nd;
                                }//for
                                nNN->got_Heap = 1;
                        }//if

                        //²åÈë
                        parent = 1;
                        //if()
                        j = 2;

                        while(j <= nNN->found)
                        {
                                if(j < nNN->found && nNN->dist2[j] < nNN->dist2[j + 1])
                                        j++;

                                if(dist2 > nNN->dist2[j])
                                        break;

                                nNN->dist2[parent] = nNN->dist2[j];
                                nNN->index[parent] = nNN->index[j];
                                parent = j;
                                j += j;
                        }//while

                        if((parent != 1)||(dist2 < nNN->dist2[parent]))
                        {
                                nNN->index[parent] = p;
                                nNN->dist2[parent] = dist2;
                        }
                        nNN->dist2[0] = nNN->dist2[1];//??????
                }//else
        }//if       
}

#define swap(kdN,a,b){ kdNode* tmp = kdN[a]; kdN[a] = kdN; kdN = tmp;}

void kdTree::medianPartition(kdNode** pOrig,const int start,const int end,const int median,const int axis)
{
        int left = start;
        int right = end;

        while(right > left)
        {
                const TYPE v = pOrig[right]->pos[axis];

                int i = left - 1;
                int j = right;

                for(;
                {
                        while(pOrig[++i]->pos[axis] < v);
                        while(pOrig[--j]->pos[axis] > v && j > left);
                        if(i >= j)
                                break;

                        swap(pOrig, i, j);
                }

                swap(pOrig, i, right);
                if(i >= median)
                        right = i - 1;
                if(i <= median)
                        left = i + 1;
        }
}
void kdTree::balancePartition(kdNode** pBalanced,kdNode** pOriginal,const int index,const int start,const int end)
{
        //¼ÆËãmedian£¬ÕâÊÇÔõô¼ÆËãµÄÄØ£¿£¿£¿
        int median = 1;
        while((4 * median) <= (end - start + 1))
                median += median;  //median*=2;

        if((3 * median) <= (end - start +1))
        {
                median += median;
                median += start - 1;
        }
        else
                median = end - median + 1;

        // ѰÕÒ·Ö¸îÊý¾ÝµÄÖá
        int axis = 2;
        if((boundrayMax[0] - boundrayMin[0]) > (boundrayMax[1] - boundrayMin[1])&&
                (boundrayMax[0] - boundrayMin[0]) > (boundrayMax[2] - boundrayMin[2]))
                axis = 0;
        else if((boundrayMax[1] - boundrayMin[1]) > (boundrayMax[2] - boundrayMin[2]))
                axis = 1;

        // °´median·Ö¸î½Úµã
        medianPartition(pOriginal, start, end, median, axis);

        pBalanced[index] = pOriginal[median];
        pBalanced[index]->plane = axis;

        // µü´úƽºâ×óÓÒ×ÓÊ÷
        if(median > start)
        {
                if(start < median - 1)
                {
                        const float tmp = boundrayMax[axis];
                        boundrayMax[axis] = pBalanced[index]->pos[axis];
                        balancePartition(pBalanced, pOriginal, 2 * index, start, median - 1);
                        boundrayMax[axis] = tmp;
                }
                else
                        pBalanced[2 * index] = pOriginal[start];
        }
        if(median < end)
        {
                if(median + 1 < end)
                {
                        const float tmp = boundrayMin[axis];
                        boundrayMin[axis] = pBalanced[index]->pos[axis];
                        balancePartition(pBalanced, pOriginal, 2 * index + 1, median + 1, end);
                        boundrayMin[axis] = tmp;
                }
                else
                        pBalanced[2 * index + 1] = pOriginal[end];
        }
}

[ Last edited by lxb9721 on 2012-7-2 at 20:27 ]
»Ø¸´´ËÂ¥

» ²ÂÄãϲ»¶

» ±¾Ö÷ÌâÏà¹Ø¼ÛÖµÌùÍÆ¼ö£¬¶ÔÄúͬÑùÓаïÖú:

ÒÑÔÄ   »Ø¸´´ËÂ¥   ¹Ø×¢TA ¸øTA·¢ÏûÏ¢ ËÍTAºì»¨ TAµÄ»ØÌû

libralibra

ÖÁ×ðľ³æ (ÖøÃûдÊÖ)

æôÆï½«¾ü

¡¾´ð°¸¡¿Ó¦Öú»ØÌû

¸Ðл²ÎÓ룬ӦÖúÖ¸Êý +1
²»ÓôúÂëblockµÄ½á¹û¾ÍÊDZðÈË¿´²»¶®
matlab/VB/python/c++/Javaд³ÌÐòÇë·¢QQÓʼþ:790404545@qq.com
2Â¥2012-07-02 20:49:24
ÒÑÔÄ   »Ø¸´´ËÂ¥   ¹Ø×¢TA ¸øTA·¢ÏûÏ¢ ËÍTAºì»¨ TAµÄ»ØÌû

c55719747

гæ (³õÈëÎÄ̳)

ÒýÓûØÌû:
2Â¥: Originally posted by libralibra at 2012-07-02 20:49:24
²»ÓôúÂëblockµÄ½á¹û¾ÍÊDZðÈË¿´²»¶®

Ì«³¤ÁË£¬Ó¦¸ÃÑ¡ÔñÓÐÎÊÌâµÄÒ»¶ÎÈÃÈËÐÞ¸Ä
3Â¥2012-07-02 21:03:23
ÒÑÔÄ   »Ø¸´´ËÂ¥   ¹Ø×¢TA ¸øTA·¢ÏûÏ¢ ËÍTAºì»¨ TAµÄ»ØÌû

wangybcn

½û³æ (ÕýʽдÊÖ)

¡ï ¡ï ¡ï ¡ï ¡ï ¡ï ¡ï ¡ï ¡ï ¡ï
¸Ðл²ÎÓ룬ӦÖúÖ¸Êý +1
lxb9721: ½ð±Ò+10, ¡ï¡ï¡ïºÜÓаïÖú, http://emuch.net/bbs/viewthread.php?tid=4698994 2012-07-05 20:38:46
±¾ÌûÄÚÈݱ»ÆÁ±Î

4Â¥2012-07-02 21:59:18
ÒÑÔÄ   »Ø¸´´ËÂ¥   ¹Ø×¢TA ¸øTA·¢ÏûÏ¢ ËÍTAºì»¨ TAµÄ»ØÌû

ÆÐÌáÉ«

ľ³æ (ÕýʽдÊÖ)

¡¾´ð°¸¡¿Ó¦Öú»ØÌû

¡ï ¡ï ¡ï ¡ï ¡ï
¸Ðл²ÎÓ룬ӦÖúÖ¸Êý +1
lxb9721: ½ð±Ò+5, ¡ï¡ï¡ïºÜÓаïÖú, http://emuch.net/bbs/viewthread.php?tid=4698994 2012-07-05 20:38:58
Ì«³¤ÁË£¬Ö±½Ó°ÑÔ´Îļþ¸ãÉÏÀ´£¬ÓпոøÄã¿´¿´
ÌìÐн¡£¬¾ý×ÓÒÔ×ÔÇ¿²»Ï¢
5Â¥2012-07-03 20:46:23
ÒÑÔÄ   »Ø¸´´ËÂ¥   ¹Ø×¢TA ¸øTA·¢ÏûÏ¢ ËÍTAºì»¨ TAµÄ»ØÌû
Ïà¹Ø°æ¿éÌø×ª ÎÒÒª¶©ÔÄÂ¥Ö÷ lxb9721 µÄÖ÷Ìâ¸üÐÂ
×î¾ßÈËÆøÈÈÌûÍÆ¼ö [²é¿´È«²¿] ×÷Õß »Ø/¿´ ×îºó·¢±í
[¿¼ÑÐ] 22408 ×Ü·Ö320£¬Ò»ÆªÂÛÎĶþ×÷£¬Á½¸ö¹úÈý£¬Çóµ÷¼Á +3 Leomulufu 2026-04-04 5/250 2026-04-05 19:04 by chongya
[¿¼ÑÐ] ÊýÒ»Ó¢Ò» 347 È˹¤ÖÇÄܹú½±ÂÛÎͼÓÐÇóµ÷¼Á +3 ÎÚÀ­¶ùɽÂö 2026-03-30 7/350 2026-04-05 10:32 by zhq0425
[¿¼ÑÐ] 266·Ö£¬Ò»Ö¾Ô¸µçÆø¹¤³Ì£¬±¾¿Æ²ÄÁÏ£¬Çó²ÄÁÏרҵµ÷¼Á +11 ÍÛºôºßºôºß 2026-04-01 12/600 2026-04-04 23:17 by ÓÀ×ÖºÅ
[¿¼ÑÐ] Ò»Ö¾Ô¸211£¬»¯Ñ§Ñ§Ë¶£¬310·Ö£¬±¾¿ÆÖصãË«·Ç£¬Çóµ÷¼Á +11 ŬÁ¦·Ü¶·112 2026-04-04 11/550 2026-04-04 20:51 by À¶ÔÆË¼Óê
[¿¼ÑÐ] 085601£¬Ò»Ö¾Ô¸Ïôó334¸´ÊÔ±»Ë¢Çóµ÷¼Á +13 ÔøÑöÖ® 2026-04-03 15/750 2026-04-04 20:13 by dongzh2009
[¿¼ÑÐ] Ò»Ö¾Ô¸°²»Õij211 0703»¯Ñ§×Ü·Ö339Çóµ÷¼Á +6 Íí·ç²»Íí 2026-04-04 6/300 2026-04-04 20:11 by dongzh2009
[¿¼ÑÐ] 26µ÷¼Á 086003 +6 ʧ»îµÄϸ°û 2026-04-04 6/300 2026-04-04 09:50 by zhangdingwa
[¿¼ÑÐ] Çóµ÷¼Á +3 wos666 2026-04-03 3/150 2026-04-04 05:16 by gswylq
[¿¼ÑÐ] 320µ÷¼Á +4 ũҵ¹¤³ÌÓëÐÅÏ¢¼ 2026-04-03 4/200 2026-04-03 21:40 by lbsjt
[¿¼ÑÐ] 285Çóµ÷¼Á +14 AZMK 2026-04-02 14/700 2026-04-02 15:54 by ÉϾÅÌìÀ¿Ô£¨ºÃÔ
[¿¼ÑÐ] 286·Öµ÷¼Á +20 Faune 2026-03-30 22/1100 2026-04-02 13:24 by clyblh
[¿¼ÑÐ] 08¹¤¿ÆÇóµ÷¼Á290·Ö +5 1314Åõ»¨ 2026-04-02 8/400 2026-04-02 13:16 by ÇÇßÕßÕßÕ
[¿¼ÑÐ] 0710ÉúÎïѧÇóµ÷¼Á +9 manman511 2026-04-01 9/450 2026-04-02 10:00 by zxl830724
[¿¼ÑÐ] 354Çóµ÷¼Á +4 lxb598 2026-03-31 5/250 2026-04-02 09:55 by Jaylen.
[¿¼ÑÐ] Ò»Ö¾Ô¸346ÉϺ£´óѧÉúÎïѧ +3 ÉϺ£´óѧ346µ÷¼Á 2026-04-01 3/150 2026-04-02 08:36 by w³æ³æ123
[¿¼ÑÐ] Ò»Ö¾Ô¸°²»Õ´óѧ¼ÆËã»ú¿ÆÑ§Óë¼¼Êõѧ˶£¬331·ÖÇóµ÷¼Á +5 ½¯²ýÅôqtj 2026-04-01 5/250 2026-04-02 08:10 by fxue1114
[¿¼ÑÐ] 085602»¯Ñ§¹¤³Ì268·Ö¶×µ÷¼Á +8 ÔÂÕÕ»¨ÁÖ¡£ 2026-04-01 8/400 2026-04-01 22:08 by Î޼ʵIJÝÔ­
[¿¼ÑÐ] 265Çóµ÷¼Á +11 yelck 2026-04-01 12/600 2026-04-01 19:12 by 549790059
[¿¼ÑÐ] 285Çóµ÷¼Á +7 AZMK 2026-03-30 13/650 2026-04-01 17:00 by Æß¶È²»ÐÅÈÎ
[¿¼ÑÐ] Ò»Ö¾Ô¸Î÷½»´ó080500²ÄÁÏѧ˶349 +6 jqx1258 2026-03-31 7/350 2026-03-31 21:08 by yuq
ÐÅÏ¢Ìáʾ
ÇëÌî´¦ÀíÒâ¼û