八叉树算法的改进

1、八叉树的定义（熟悉的直接跳到第二步）
 
你有一个立方体，按照如下方法给它三刀：

横切一刀，竖劈一刀，在与之前竖劈方向垂直的方向再砍一刀，这样就分成八个大小相同的立方体；

对小立方体重复砍劈。。。。。

2、分析
(1) 构建规则的八叉树 
如果构建规则的八叉树 ，则结构所占的空间将非常大，而且很多情况下这些结构都是无用的；
常规构建方法：

struct OctTreeNode{

    LHLONG tag;//对于叶节点，为统计的颜色数；对于非叶节点，恒为-1。

    struct OctTreeNode *pChild[8];//下一级节点

};

 //创建八叉树

int depth = 6; 
OctTreeNode *pRootNode = NULL;

m_depth = depth;

m_nodeNum = 1;

for(LHINT i=1; i<=m_depth; i++){

    m_nodeNum += (1 << ((i << 2) - i));

}

pRootNode = (OctTreeNode *)LHMalloc((m_nodeNum << 5) + (m_nodeNum << 2));//OctTreeNode的大小为36字节，分解为32（2的5次方）+ 4（2的平方）

if(pRootNode == NULL){

    goto initialize_octTree_fail;

}

memset(pRootNode, 0, sizeof(OctTreeNode));

pRootNode->tag = -1;

ret = createOctTree(1, pRootNode);


//递归函数

int createOctTree(int  depth, OctTreeNode *pParent){

    static LHDWORD _nodeIndex = 1;

    if(depth < (m_depth)){

        for(int  i=0; i<8; i++){

            pParent->pChild[i] = &pRootNode[_nodeIndex];

            memset(pParent->pChild[i], 0, sizeof(OctTreeNode));

            pParent->pChild[i]->tag = -1;

            _nodeIndex ++;

            createOctTree(depth + 1, pParent->pChild[i]);

        }

    }else{

        for(int  i=0; i<8; i++){

            pParent->pChild[i] = &pRootNode[_nodeIndex];

            memset(pParent->pChild[i], 0, sizeof(OctTreeNode));

            _nodeIndex ++;

        }

        if(_nodeIndex >= m_nodeNum){

            _nodeIndex = 1;

        }

    }

    return 0;

} 

(2) 运行上面的程序，你将会发现你的内存狂涨！！！
解决办法：优化。
只使用叶节点，其余的都丢弃！

struct _node{

DWORD num;

};

void Test()

{

DWORD r = 0;

DWORD g = 0;

DWORD b = 0;

DWORD ret = 0;

DWORD size = 400000;

_node *pList = (_node *)malloc(size * sizeof(_node));//这个就是简化之后的八叉树！！！

memset(pList, 0, size * sizeof(_node));

FILE *fd = fopen("data.dat", "wb");

char info[128] = {0};

BYTE depth = 6;

for(r=0; r<256; r++){

for(g=0; g<256; g++){

for(b=0; b<256; b++){

ret = (((r >> (8 - depth)) << (depth << 1)) | ((g >> (8 - depth)) << depth) | (b >> (8 - depth)));

pList[ret].num ++;

}

}

}

for(DWORD i=0; i<size; i++){

if(pList[i].num != 0){

sprintf(info, "%08lu      %lu\n", i, pList[i]);

fwrite(info, 1, strlen(info), fd);

}else{

break;

}

}

fclose(fd);

free(pList);

}  
记录的文件如下：

00000000      64

00000001      64

00000002      64

00000003      64

00000004      64

00000005      64

00000006      64

00000007      64

00000008      64

00000009      64

00000010      64

00000011      64

00000012      64
。。。。  
。。。。 

00130949      64

00130950      64

00130951      64

00130952      64

00130953      64

00130954      64

00130955      64

00130956      64

00130957      64

00130958      64

00130959      64 
。。。。  
。。。。  

00262131      64

00262132      64

00262133      64

00262134      64

00262135      64

00262136      64

00262137      64

00262138      64

00262139      64

00262140      64

00262141      64

00262142      64

00262143      64
设置的是六级的深度，一共是262144条数据，占用内存为1M！而构建规则的六级深度的八叉树，一共有299592个节点（不算根节点，只算子节点和叶节点），按照每个叶节点占用32字节，结构内存将达到9.142822265625M，难以接受！
 

至于查找、修改等操作，上面的代码演示的很清楚了。