无法在自定义树中插入超过256个节点
Unable to insert more than 256 nodes into a custom tree
我已经在这个问题上坚持了很长一段时间，甚至在Ubuntu上测试了64位版本的gcc和Windows（MinGW）上的32位gcc之间的问题。
每当我在二叉树（？）中插入超过256个节点时，它就会停止计算节点数。我仍然可以访问我的所有数据。我有一种感觉，这与我的结构设置方式有关，通过使用字符来获取每个字节的每一位，但我不知道如何修复它
在这个标题中，我有一个结构和一些功能设置，它允许我获取对象的单个位。
这是实际的树实现。为了找到存储每个对象的位置，树遍历键的每个字节，然后再次遍历这些字节的每个位。不过，"迭代"函数是给我带来最大困难的；我不知道为什么，但一旦256个节点被数据填满，我的结构就会停止进一步计数，然后开始替换所有以前的数据。我相信这与单个字符只能容纳0-256的事实有关，但我看不出这会是什么问题。由于每个节点的位置是由密钥的各个位决定的，因此很难确定为什么只有256个项目可以放入树中。
我的测试程序的URL在帖子的底部。所以现在不会让我发布超过2个。我希望尽快完成这项工作，所以如果有任何帮助，我们将不胜感激。
编辑：为了让事情变得更容易，这是一种结构，它为我提供了字节的单个位，以及一个辅助函数：
struct bitMask {
char b1 : 1;
char b2 : 1;
char b3 : 1;
char b4 : 1;
char b5 : 1;
char b6 : 1;
char b7 : 1;
char b8 : 1;
char operator[] ( unsigned i ) const {
switch( i ) {
case 0 : return b1;
case 1 : return b2;
case 2 : return b3;
case 3 : return b4;
case 4 : return b5;
case 5 : return b6;
case 6 : return b7;
case 7 : return b8;
}
return 0; // Avoiding a compiler error
}
};
/******************************************************************************
* Functions shared between tree-type objects
******************************************************************************/
namespace treeShared {
// Function to retrieve the next set of bits at the pointer "key"
template <typename key_t>
inline const bitMask* getKeyByte( const key_t* key, unsigned iter );
/* template specializations */
template <>
inline const bitMask* getKeyByte( const char*, unsigned );
template <>
inline const bitMask* getKeyByte( const wchar_t*, unsigned );
template <>
inline const bitMask* getKeyByte( const char16_t*, unsigned );
template <>
inline const bitMask* getKeyByte( const char32_t*, unsigned );
} // end treeShared namespace
/*
* Tree Bit Mask Function
*/
template <typename key_t>
inline const bitMask* treeShared::getKeyByte( const key_t* k, unsigned iter ) {
return (iter < sizeof( key_t ))
? reinterpret_cast< const bitMask* >( k+iter )
: nullptr;
}
/*
* Tree Bit Mask Specializations
*/
template <>
inline const bitMask* treeShared::getKeyByte( const char* str, unsigned iter ) {
return (str[ iter ] != ' ')
? reinterpret_cast< const bitMask* >( str+iter )
: nullptr;
}
template <>
inline const bitMask* treeShared::getKeyByte( const wchar_t* str, unsigned iter ) {
return (str[ iter ] != ' ')
? reinterpret_cast< const bitMask* >( str+iter )
: nullptr;
}
template <>
inline const bitMask* treeShared::getKeyByte( const char16_t* str, unsigned iter ) {
return (str[ iter ] != ' ')
? reinterpret_cast< const bitMask* >( str+iter )
: nullptr;
}
template <>
inline const bitMask* treeShared::getKeyByte( const char32_t* str, unsigned iter ) {
return (str[ iter ] != ' ')
? reinterpret_cast< const bitMask* >( str+iter )
: nullptr;
}
这是树类：
template <typename data_t>
struct bTreeNode {
data_t* data = nullptr;
bTreeNode* subNodes = nullptr;
~bTreeNode() {
delete data;
delete [] subNodes;
data = nullptr;
subNodes = nullptr;
}
};
/******************************************************************************
* Binary-Tree Structure Setup
******************************************************************************/
template <typename key_t, typename data_t>
class bTree {
enum node_dir : unsigned {
BNODE_LEFT = 0,
BNODE_RIGHT = 1,
BNODE_MAX
};
protected:
bTreeNode<data_t> head;
unsigned numNodes = 0;
private:
bTreeNode<data_t>* iterate( const key_t* k, bool createNodes );
public:
~bTree() {}
// STL-Map behavior
data_t& operator [] ( const key_t& k );
void push ( const key_t& k, const data_t& d );
void pop ( const key_t& k );
bool hasData ( const key_t& k );
const data_t* getData ( const key_t& k );
unsigned size () const { return numNodes; }
void clear ();
};
/*
* Binary-Tree -- Element iteration
*/
template <typename key_t, typename data_t>
bTreeNode<data_t>* bTree<key_t, data_t>::iterate( const key_t* k, bool createNodes ) {
node_dir dir;
unsigned bytePos = 0;
bTreeNode<data_t>* bNodeIter = &head;
const bitMask* byteIter = nullptr;
while ( byteIter = treeShared::getKeyByte< key_t >( k, bytePos++ ) ) {
for ( int currBit = 0; currBit < HL_BITS_PER_BYTE; ++currBit ) {
// compare the bits of each byte in k
dir = byteIter->operator []( currBit ) ? BNODE_LEFT : BNODE_RIGHT;
// check to see if a new bTreeNode needs to be made
if ( !bNodeIter->subNodes ) {
if ( createNodes ) {
// create and initialize the upcoming sub bTreeNode
bNodeIter->subNodes = new bTreeNode<data_t>[ BNODE_MAX ];
}
else {
return nullptr;
}
}
// move to the next bTreeNode
bNodeIter = &(bNodeIter->subNodes[ dir ]);
}
}
return bNodeIter;
}
/*
* Binary-Tree -- Destructor
*/
template <typename key_t, typename data_t>
void bTree<key_t, data_t>::clear() {
delete head.data;
delete [] head.subNodes;
head.data = nullptr;
head.subNodes = nullptr;
numNodes = 0;
}
/*
* Binary-Tree -- Array Subscript operators
*/
template <typename key_t, typename data_t>
data_t& bTree<key_t, data_t>::operator []( const key_t& k ) {
bTreeNode<data_t>* iter = iterate( &k, true );
if ( !iter->data ) {
iter->data = new data_t();
++numNodes;
}
return *iter->data;
}
/*
* Binary-Tree -- Push
* Push a data element to the tree using a key
*/
template <typename key_t, typename data_t>
void bTree<key_t, data_t>::push( const key_t& k, const data_t& d ) {
bTreeNode<data_t>* iter = iterate( &k, true );
if ( !iter->data ) {
iter->data = new data_t( d );
++numNodes;
}
else {
*iter->data = d;
}
}
/*
* Binary-Tree -- Pop
* Remove whichever element lies at the key
*/
template <typename key_t, typename data_t>
void bTree<key_t, data_t>::pop( const key_t& k ) {
bTreeNode<data_t>* iter = iterate( &k, false );
if ( !iter || !iter->data )
return;
delete iter->data;
iter->data = nullptr;
--numNodes;
}
/*
* Binary-Tree -- Has Data
* Return true if there is a data element at the key
*/
template <typename key_t, typename data_t>
bool bTree<key_t, data_t>::hasData( const key_t& k ) {
bTreeNode<data_t>* iter = iterate( &k, false );
return iter && ( iter->data != nullptr );
}
/*
* Binary-Tree -- Push
* Return a pointer to the data that lies at a key
* Returns a nullptr if no data exists
*/
template <typename key_t, typename data_t>
const data_t* bTree<key_t, data_t>::getData( const key_t& k ) {
bTreeNode<data_t>* iter = iterate( &k, false );
if ( !iter )
return nullptr;
return iter->data;
}
pastebin.com/8MZ0TMpj
template <typename key_t> inline const bitMask* treeShared::getKeyByte( const key_t* k, unsigned iter ) { return (iter < sizeof( key_t )) ? reinterpret_cast< const bitMask* >( k+iter ) : nullptr; }
这并不像你想象的那样。（k+iter）不检索k的第iter个字节，而是检索k指向的key_t[]数组的第iterth个元素。换句话说，k+iter将指针前进iter*sizeof（key_t）字节，而不是iter字节。
从形式上讲，这段代码通过超越数组边界表现出未定义的行为。实际上，您的程序只使用密钥的一个字节，然后sizeof（key_t）-1随机字节恰好位于该密钥上方的内存中。这就是为什么你被有效地限制在8位状态。
此外，从形式上讲，您的reinterpret_cast还表现出未定义的行为。使用interpret_cast获得的指针的唯一合法用途是将其重新解释为原始类型。不过，这并不是你问题的直接原因。
相关文章：
- 如何使用发送数据包所花费的时间计算两个节点之间的距离?
- 为什么我的双向链表删除函数会删除多个节点?
- 检查两个节点在子节点上是否具有相同状态的更优雅的方法
- 比较两个节点坐标的最佳方法是什么?
- 生成所有具有 n 个节点的无向图
- 使用 Dijkstra 算法跟踪两个节点之间的最短路径
- 只有我的"链接列表"中的第一个节点正在打印
- 双向链表 - 无法删除第一个节点
- 如何仅在 2 个节点之间获取最短路径，给定邻接列表有向图?
- 图问题:找出两个节点是否在每个节点的O(1）时间和O(2）存储中共享同一分支
- 如何在单个链表中交换两个节点的位置，只修改指针
- 如何检查一行中的3个节点是否相同C++?
- 如何遍历具有两个节点的链接节点
- 链表中头/第一个节点的声明
- 查找树中两个节点之间的最大成本边
- 链表.如何删除列表中的第一个节点?
- 链表 C++中的多个节点
- C MPI，使用多个节点，首先在节点级别上降低，然后减小到头节点
- 查找树(不属于任何特定类型的简单连接树）中两个节点之间的路径
- 无法在自定义树中插入超过256个节点
