C++ BinaryNode类代码示例

long long BinaryTree::nodeCounts() {
    std::queue<BinaryNode*> collections;

    // Find first leaf and push it to stack
    collections.push(root_);
    long long count = 1;

    // Iterate the cell from root to its childrens to destory
    // binary tree
    BinaryNode* cell = NULL;
    while (!collections.empty())
    {
        cell = collections.front();
        collections.pop();

        // Push the children to stack
        if (!cell->isLeaf()) {
            BinaryNode *leftChild = cell->leftChild();
            BinaryNode *rightChild = cell->rightChild();
            if (leftChild != NULL) collections.push(leftChild);
            if (rightChild != NULL) collections.push(rightChild);
        }

        // Count the current node
        count++;
    }

    return count;
}

bool Container::unserializeItemNode_OTMM(const IOMap& maphandle, BinaryNode* node)
{
	bool ret = Item::unserializeAttributes_OTMM(maphandle, node);

	if(ret) {
		BinaryNode* child = node->getChild();
		if(child) do {
			uint8_t type;
			if(!child->getByte(type)) {
				return false;
			}
			//load container items
			if(type == OTMM_ITEM) {
				Item* item = Item::Create_OTMM(maphandle, child);
				if(!item) {
					return false;
				}
				if(!item->unserializeItemNode_OTMM(maphandle, child)) {
					delete item;
					return false;
				}
				contents.push_back(item);
			} else {
				// corrupted file data!
				return false;
			}
		} while(child->advance());
		return true;
	}
	return false;
}

BinaryNode<T> *BST<T>::find_max(BinaryNode<T> *node) {

	// 	Keep going down rhs until rhs == NULL. Then return the node
	BinaryNode<T> *tmp = node;

	while (tmp->get_rhs() != NULL){
		tmp = tmp->get_rhs();
	}

	return tmp;



	// 	THIS IS ALL COMMENTED OUT TEMPORARILY BECAUSE OF ISSUES WITH ACCESSING THE NODES IN TREE
	// 	if (root != NULL){
	// 		BinaryNode<T> * entire_fucking_tree;
	// 		entire_fucking_tree = root;
	// 		root = NULL;
	// 		return entire_fucking_tree;
	// 	}
	// 		

	// TODO: Implement this function
	throw 1;
	// TODO: Implement this function (when you have a use for it)
	return NULL;
}

BinaryNode<ItemType>* BinaryNodeTree<ItemType>::moveValuesUpTree(BinaryNode<ItemType>* subTreePtr)
{
   BinaryNode<ItemType>* leftPtr = subTreePtr->getLeftChildPtr();
   BinaryNode<ItemType>* rightPtr = subTreePtr->getRightChildPtr();
   int leftHeight = getHeightHelper(leftPtr);
   int rightHeight = getHeightHelper(rightPtr);
   if (leftHeight > rightHeight)
   {
      subTreePtr->setItem(leftPtr->getItem());
      leftPtr = moveValuesUpTree(leftPtr);
      subTreePtr->setLeftChildPtr(leftPtr);
      return subTreePtr;
   }
   else 
   {
      if (rightPtr != nullptr)
      {
         subTreePtr->setItem(rightPtr->getItem());
         rightPtr =moveValuesUpTree(rightPtr);         
         subTreePtr->setRightChildPtr(rightPtr);
         return subTreePtr;
      }
      else 
      {
         //this was a leaf!
         // value not important
         delete subTreePtr;
         return nullptr;
      }  // end if
   }  // end if   
}  // end moveValuesUpTree

 BinaryNode<ItemType>* copyTree(const BinaryNode<ItemType>* treePtr) const {
     BinaryNode<ItemType>* newTreePtr = nullptr;
     if (treePtr != nullptr) {
         newTreePtr = new BinaryNode<ItemType>(treePtr->getItem(), nullptr, nullptr);
         newTreePtr->setLeftChildPtr(copyTree(treePtr->getLeftChildPtr()));
         newTreePtr->setRightChildPtr(copyTree(treePtr->getRightChildPtr()));
     }
     return newTreePtr;
 }

ItemType BinaryNodeTree<ItemType>::getEntry(const ItemType& anEntry) const throw(NotFoundException)
{
   bool isSuccessful = false;
   BinaryNode<ItemType>* binaryNodePtr = findNode(rootPtr, anEntry, isSuccessful);
   
   if (isSuccessful)
      return binaryNodePtr->getItem(); 
   else 
      throw NotFoundException("Entry not found in tree!");
}  // end getEntry

double Division::eval() const
{
  BinaryNode* p;
  p = dynamic_cast<BinaryNode*>(owner_);
  if (p == 0)
  {
    std::cerr << "this cannot happen" << std::endl;
    exit(1);
  } 
  return p->getLeft() / p->getRight();
}

BinaryNode<ItemType>* BinaryNodeTree<ItemType>::copyTree(const BinaryNode<ItemType>* treePtr) const
{
   BinaryNode<ItemType>* newTreePtr = nullptr;
   
   // Copy tree nodes during a preorder traversal
   if (treePtr != nullptr)
   {
      // Copy node
	   newTreePtr = new BinaryNode<ItemType>(treePtr->getItem(), nullptr, nullptr);
	   newTreePtr->setLeftChildPtr(copyTree(treePtr->getLeftChildPtr()));
      newTreePtr->setRightChildPtr(copyTree(treePtr->getRightChildPtr()));
   }  // end if
   
   return newTreePtr;
}  // end copyTree

BinaryNode* BinaryTree::copyTree(const BinaryNode* nodePtr)
{
    if (nodePtr == 0)
    {
        return 0;
    }
    
    else
    {
        // make a new node
        BinaryNode* newNode = new BinaryNode(nodePtr->getWebsite());
        newNode->setLeftPtr(copyTree(nodePtr->getLeftPtr()));
        newNode->setRightPtr(copyTree(nodePtr->getRightPtr()));
        return newNode;
    }
}

void BinaryHeap::sort(){
    
    BinaryNode* currentNode = last;
    
    // Sift the item up so long as it has a parent (not root)
    // and is greater than it's parent.
    while(currentNode->hasParent()){
        if(*currentNode > *currentNode->parent){
            int temp = currentNode->data;
            currentNode->setData(currentNode->parent->data);
            currentNode->parent->setData(temp);
            currentNode = currentNode->parent;
        }
        else{
            currentNode = root;
        }
    }
}

int BinaryNode::substr(BinaryNode& b, qore_offset_t offset) const {
   printd(5, "BinaryNode::substr(offset: "QSD") this: %p len: "QSD")\n", offset, this, len);

   checkOffset(offset);
   if (offset == (qore_offset_t)len)
      return -1;

   b.append((char*)ptr + offset, len - offset);
   return 0;
}

void BinaryHeap::setLast(){
    if(!last){
        BinaryNode* currentNode = root;
        
        // While our node has children we will check
        // to see if it has a right branch. If it doesn't
        // we will set to the left (which it must have).
        while(currentNode->hasChildren()){
            if(currentNode->hasRightChild()){
                currentNode = currentNode->rightChild;
            }
            else{
                currentNode = currentNode->leftChild;
            }
        }
        
        // We've reached a node with no children, our last element.
        last = currentNode;
    }
}

ClientVersionID IOMapOTMM::getVersionInfo(const FileName& filename)
{
	wxString wpath = filename.GetFullPath();
	DiskNodeFileReadHandle f((const char*)wpath.mb_str(wxConvUTF8));
	if(f.isOk() == false) {
		return CLIENT_VERSION_NONE;
	}

	BinaryNode* root = f.getRootNode();
	if(!root) {return CLIENT_VERSION_NONE;}
	root->skip(1); // Skip the type byte

	uint16_t u16;
	uint32_t u32;

	if(!root->getU32(u32) || u32 != 1) { // Version
		return CLIENT_VERSION_NONE;
	}

	root->getU16(u16);
	root->getU16(u16);
	root->getU32(u32);

	if(root->getU32(u32)) { // OTB minor version
		return ClientVersionID(u32);
	}
	return CLIENT_VERSION_NONE;
}

void BST::deleteMin()
{
	
	if (rootPtr->getLeftChildPtr()==nullptr && rootPtr->getRightChildPtr()!=nullptr)
	{
		BinaryNode* toDelete = rootPtr-> getRightChildPtr();
		rootPtr = rootPtr-> getRightChildPtr();
		delete toDelete;
	}
	else if (rootPtr->getLeftChildPtr()==nullptr)
	{
		delete rootPtr;
	}
	else
	{
		BinaryNode* parent = rootPtr;
		BinaryNode* child = rootPtr->getLeftChildPtr();
		while (child->getLeftChildPtr()!=nullptr)
		{
			child = child->getLeftChildPtr();
			parent = parent->getLeftChildPtr();
		}
		
		delete child;
		parent->setLeftChildPtr(nullptr);
	}
}

T BST<T>::remove_root() {

	if (root == NULL) throw 3; //no root

	T retData = root->get_data();
	T maxData;
	BinaryNode<T>* tmpNode;

	if (root->get_lhs() == NULL){
		BinaryNode<T> *tmpRoot = root;
		root = root->get_rhs();
		delete tmpRoot;
		return retData;
	}

	tmpNode = find_max(root->get_lhs());
	maxData = tmpNode->get_data();
	if(remove(maxData) != maxData) throw 2; //removed the wrong data
	root->set_data(maxData);
	return retData;

	throw 1;
}