// There are branches in trees, and tree B is not a subtree of tree A // 8 8 // / \ / \ // 8 7 9 2 // / \ // 9 3 // / \ // 4 7 void Test2() { BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(7); BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(3); BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode(4); BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode(7); ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3); ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5); ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7); BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2); ConnectTreeNodes(pNodeB1, pNodeB2, pNodeB3); Test("Test2", pNodeA1, pNodeB1, false); DestroyTree(pNodeA1); DestroyTree(pNodeB1); }
int main(void) { unsigned char pkt[200]; req r; ssize_t len; unsigned int i; FILE *in; uint32_t seed; signal(SIGALRM, tooslow); alarm(TIMEOUT); // set up the head of the SNMP MIB tree InitTree(); SetCount = 0; ErrCount = 0; // seed the prng if ((in = fopen("/dev/urandom", "r")) == NULL) { exit(-1); } if (fread(&seed, 1, 4, in) != 4) { exit(-1); } fclose(in); srand(seed); // init the MIB with some objects PopulateMIB(); while (1) { if (ErrCount > MAX_ERRORS) { DestroyTree(MIB); exit(-1); } bzero(pkt, 200); bzero(&r, sizeof(req)); if ((len = ReceivePacket(pkt, 200)) == 0) { DestroyTree(MIB); exit(-1); } // reset the timer alarm(TIMEOUT); // parse the packet and handle the particular request if (ParseSnmpPkt(pkt, len, &r)) { if (r.type == GET_REQUEST) { HandleGetRequest(&r); } else if (r.type == GET_NEXT_REQUEST) { HandleGetNextRequest(&r); } else if (r.type == SET_REQUEST) { HandleSetRequest(&r); } } else { // error parsing packet ErrCount++; } } }
// Nodes in tree A only have right children, and tree B is not a subtree of tree A // 8 8 // \ \ // 8 9 // \ / \ // 9 3 2 // \ // 2 // \ // 5 void Test6() { BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2); BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5); ConnectTreeNodes(pNodeA1, NULL, pNodeA2); ConnectTreeNodes(pNodeA2, NULL, pNodeA3); ConnectTreeNodes(pNodeA3, NULL, pNodeA4); ConnectTreeNodes(pNodeA4, NULL, pNodeA5); BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(3); BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode(2); ConnectTreeNodes(pNodeB1, NULL, pNodeB2); ConnectTreeNodes(pNodeB2, pNodeB3, pNodeB4); Test("Test6", pNodeA1, pNodeB1, false); DestroyTree(pNodeA1); DestroyTree(pNodeB1); }
Status DeleteChild(CSTree &T, CSTree p, int i) { CSTree b, q; int j; if (T) { if (i == 1) { b = p->firstchild; p->firstchild = b->nextsibling; b->nextsibling = NULL; DestroyTree(b); } else { q = p->firstchild; j = 2; while (q && j < i) { q = q->nextsibling; j++; } if (j == i) { b = q->nextsibling; q->nextsibling = b->nextsibling; b->nextsibling = NULL; DestroyTree(b); } else { return ERROR; } } return OK; } else { return ERROR; } }
// Nodes in trees only have left children, and tree B is a subtree of tree A // 8 8 // / / // 8 9 // / / // 9 2 // / // 2 // / // 5 void Test3() { BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2); BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5); ConnectTreeNodes(pNodeA1, pNodeA2, NULL); ConnectTreeNodes(pNodeA2, pNodeA3, NULL); ConnectTreeNodes(pNodeA3, pNodeA4, NULL); ConnectTreeNodes(pNodeA4, pNodeA5, NULL); BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8); BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9); BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2); ConnectTreeNodes(pNodeB1, pNodeB2, NULL); ConnectTreeNodes(pNodeB2, pNodeB3, NULL); Test("Test3", pNodeA1, pNodeB1, true); DestroyTree(pNodeA1); DestroyTree(pNodeB1); }
/** * 删除一棵树,并释放相应的结点空间 * 注意,不要忘了加&,否则T无法释放 */ void DestroyTree(BiTree &T) { if (T) { DestroyTree(T->lchild); //先删除左右子树 DestroyTree(T->rchild); free(T); T = NULL; } }
void DestroyTree(CSTree &T) { if (T) { DestroyTree(T->firstchild); DestroyTree(T->nextsibling); free(T); T = NULL; } }
void BinaryTree::DestroyTree ( node* leaf ) { if ( leaf != NULL ) { DestroyTree ( leaf->left ); DestroyTree ( leaf->right ); delete leaf; } }
static void DestroyTree( BinTree T ) { if( T != NULL ) { DestroyTree( T->LeftChild ); DestroyTree( T->NextSibling ); free( T ); } }
/* This frees the memory for a binary tree of type LEAF* using recursion the parameter is the head of the tree. */ void DestroyTree(LEAF* head) { if (head == NULL) { return; } else { DestroyTree(head->lchild); DestroyTree(head->rchild); free(head); } }
void DestroyTree(BSTreeNode* root) { if(root) { DestroyTree(root->m_pLeft); DestroyTree(root->m_pRight); delete root; root = 0; } }
void BinarySearchTree::DestroyTree( Node *node ) { if ( node != nullptr ) { DestroyTree( node->left ); DestroyTree( node->right ); delete node; node = nullptr; } }
// Release the resources void BinaryTreeMethod::DestroyTree(TreeNode **p_Root) { if(!p_Root || !(*p_Root)) { return; } DestroyTree(&((*p_Root)->p_left)); DestroyTree(&((*p_Root)->p_right)); delete *p_Root; p_Root = 0; }
void DestroyTree(CSTree *T) { /* 初始条件: 树T存在。操作结果: 销毁树T */ if(*T) { if((*T)->firstchild) /* T有长子 */ DestroyTree(&(*T)->firstchild); /* 销毁T的长子为根结点的子树 */ if((*T)->nextsibling) /* T有下一个兄弟 */ DestroyTree(&(*T)->nextsibling); /* 销毁T的下一个兄弟为根结点的子树 */ free(*T); /* 释放根结点 */ *T=NULL; } }
static void DestroyTree(CSTree &T) { // 初始条件: 树T存在。操作结果: 销毁树T if(T) { if(T->firstchild) // T有长子 DestroyTree(T->firstchild); // 销毁T的长子为根结点的子树 if(T->nextsibling) // T有下一个兄弟 DestroyTree(T->nextsibling); // 销毁T的下一个兄弟为根结点的子树 free(T); // 释放根结点 T=NULL; } }
void DestroyTree(BinaryTreeNode* pRoot) { if(pRoot != NULL) { BinaryTreeNode* pLeft = pRoot->m_pLeft; BinaryTreeNode* pRight = pRoot->m_pRight; delete pRoot; pRoot = NULL; DestroyTree(pLeft); DestroyTree(pRight); } }
void DestroyTree(BNode** tree) { if (!tree || !*tree) { return; } BNode* pTree = *tree; DestroyTree(&(pTree->left)); DestroyTree(&(pTree->right)); delete pTree; *tree = nullptr; }
BOOL TestDestroyTree() { PTreeNode pTreeHead = NULL; PTreeNode pNode = NULL ; PTreeNode pChild = NULL ; int sum = 0 ; int j = 0 ; pTreeHead = new TreeNode ; NULLVALUE_CHECK(pTreeHead, TestDestroyTree) ; //InitTreeNode(pTreeHead) ; // 添加树节点 int i = 0 ; for (; i < 3; ++i) { pNode = new TreeNode ; //InitTreeNode(pNode) ; pNode->dwAddress = sum++ ; pTreeHead->list.push_back(pNode) ; pChild = new TreeNode ; //InitTreeNode(pChild) ; pChild->dwAddress = sum++ ; pNode->list.push_back(pChild) ; } DestroyTree(pTreeHead) ; OutputDebugString(_T("TestDestroyTree pass !\r\n")) ; return TRUE ; }
bool ON_Mesh::DeleteFace( int meshfi ) { // Do NOT add a call Compact() in this function. // Compact() is slow and this function may be called // many times in sequence. // It is the callers responsibility to call Compact() // when it is needed. bool rc = false; if ( meshfi >= 0 && meshfi < m_F.Count() ) { if ( m_top.m_topf.Count() > 0 ) { DestroyTopology(); } DestroyPartition(); DestroyTree(); if ( m_FN.Count() == m_F.Count() ) { m_FN.Remove(meshfi); } m_F.Remove(meshfi); // 6 Mar 2010 S. Baer // Invalidate the cached IsClosed flag. This forces the mesh to // recompute IsClosed the next time it is called SetClosed(-1); rc = true; } return rc; }
int main(int argc, char *argv[]) { if (CheckArgCount(argc) == 0) { return EXIT_FAILURE; } /* Open the input file */ FILE* fptr = NULL; if ((fptr = OpenFile(argv[1], "rb")) == NULL) { return EXIT_FAILURE; } /* Generate the huffman tree from the header of the file */ LEAF* head = NULL; int charactersInData; if ((head = GenerateTree(fptr, &charactersInData)) == NULL) { /* After this call fptr is pointing to the data */ return EXIT_FAILURE; } /* Open the output file */ FILE* outfptr = NULL; if ((outfptr = OpenFile(argv[2], "w+")) == NULL) { return EXIT_FAILURE; } /* Print the data to the output file */ DecodeUsingTree(fptr, outfptr, head, charactersInData); /* When we make this call fptr is pointing directly to the data */ fclose(fptr); fclose(outfptr); // PostOrderWalk(head); DestroyTree(head); return EXIT_SUCCESS; }
// ====================测试代码==================== // 8 // 6 10 // 5 7 9 11 void Test1() { BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8); BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6); BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10); BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7); BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9); BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11); ConnectTreeNodes(pNode8, pNode6, pNode10); ConnectTreeNodes(pNode6, pNode5, pNode7); ConnectTreeNodes(pNode10, pNode9, pNode11); printf("====Test1 Begins: ====\n"); printf("Expected Result is:\n"); printf("8 \n"); printf("10 6 \n"); printf("5 7 9 11 \n\n"); printf("Actual Result is: \n"); Print(pNode8); printf("\n"); DestroyTree(pNode8); }
// There is only one node in a tree void Test4() { BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1); Test("Test4", pNode1); DestroyTree(pNode1); }
// 5 // / // 4 // / // 3 // / // 2 // / // 1 void TestB() { BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4); BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3); BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2); BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1); ConnectTreeNodes(pNode5, pNode4, nullptr); ConnectTreeNodes(pNode4, pNode3, nullptr); ConnectTreeNodes(pNode3, pNode2, nullptr); ConnectTreeNodes(pNode2, pNode1, nullptr); Test("TestB0", pNode5, 0, true, -1); Test("TestB1", pNode5, 1, false, 1); Test("TestB2", pNode5, 2, false, 2); Test("TestB3", pNode5, 3, false, 3); Test("TestB4", pNode5, 4, false, 4); Test("TestB5", pNode5, 5, false, 5); Test("TestB6", pNode5, 6, true, -1); DestroyTree(pNode5); printf("\n\n"); }
// 8 // 6 10 // 5 7 9 11 void TestA() { BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8); BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6); BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10); BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7); BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9); BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11); ConnectTreeNodes(pNode8, pNode6, pNode10); ConnectTreeNodes(pNode6, pNode5, pNode7); ConnectTreeNodes(pNode10, pNode9, pNode11); Test("TestA0", pNode8, 0, true, -1); Test("TestA1", pNode8, 1, false, 5); Test("TestA2", pNode8, 2, false, 6); Test("TestA3", pNode8, 3, false, 7); Test("TestA4", pNode8, 4, false, 8); Test("TestA5", pNode8, 5, false, 9); Test("TestA6", pNode8, 6, false, 10); Test("TestA7", pNode8, 7, false, 11); Test("TestA8", pNode8, 8, true, -1); DestroyTree(pNode8); printf("\n\n"); }
// 树中只有1个结点 void Test6() { BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1); Test("Test6", pNode1, true); DestroyTree(pNode1); }
// ====================测试代码==================== // 测试完全二叉树:除了叶子节点,其他节点都有两个子节点 // 8 // 6 10 // 5 7 9 11 void Test1() { printf("=====Test1 starts:=====\n"); BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8); BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6); BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10); BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7); BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9); BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11); ConnectTreeNodes(pNode8, pNode6, pNode10); ConnectTreeNodes(pNode6, pNode5, pNode7); ConnectTreeNodes(pNode10, pNode9, pNode11); PrintTree(pNode8); printf("=====Test1: MirrorRecursively=====\n"); MirrorRecursively(pNode8); PrintTree(pNode8); printf("=====Test1: MirrorIteratively=====\n"); MirrorIteratively(pNode8); PrintTree(pNode8); DestroyTree(pNode8); }
// ---------------------------------------------------------------------------- void IKSolver::SetAlgorithm(IKSolver::Algorithm algorithm) { algorithm_ = algorithm; /* We need to rebuild the tree so make sure that the scene is in the * initial pose when this occurs.*/ if (node_ != nullptr) ApplyOriginalPoseToScene(); // Initial flags for when there is no solver to destroy uint8_t initialFlags = 0; // Destroys the tree and the solver if (solver_ != nullptr) { initialFlags = solver_->flags; DestroyTree(); ik_solver_destroy(solver_); } switch (algorithm_) { case ONE_BONE : solver_ = ik_solver_create(SOLVER_ONE_BONE); break; case TWO_BONE : solver_ = ik_solver_create(SOLVER_TWO_BONE); break; case FABRIK : solver_ = ik_solver_create(SOLVER_FABRIK); break; /*case MSD : solver_ = ik_solver_create(SOLVER_MSD); break;*/ } solver_->flags = initialFlags; if (node_ != nullptr) RebuildTree(); }
// 测试二叉树:出叶子结点之外,左右的结点都有且只有一个左子结点 // 8 // 7 // 6 // 5 // 4 void Test2() { printf("=====Test2 starts:=====\n"); BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8); BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7); BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6); BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4); ConnectTreeNodes(pNode8, pNode7, NULL); ConnectTreeNodes(pNode7, pNode6, NULL); ConnectTreeNodes(pNode6, pNode5, NULL); ConnectTreeNodes(pNode5, pNode4, NULL); PrintTree(pNode8); printf("=====Test2: MirrorRecursively=====\n"); MirrorRecursively(pNode8); PrintTree(pNode8); printf("=====Test2: MirrorIteratively=====\n"); MirrorIteratively(pNode8); PrintTree(pNode8); DestroyTree(pNode8); }
int main(int argc, char **argv) { CSTree T; TElemType e; TElemType e1; InitTree(&T); printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",\ TreeEmpty(T), Root(T), TreeDepth(T)); CreateTree(&T); printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",\ TreeEmpty(T), Root(T), TreeDepth(T)); printf("先根遍历树T:\n"); PreOrderTraverse(T, vi); printf("\n请输入等修改的结点的值 新值:"); scanf("%c%*c%c%*c", &e, &e1); Assign(&T, e, e1); printf("后根遍历修改后的树T:\n"); PostOrderTraverse_recurssion1(T, vi); printf("\n"); printf("PostOrderTraverse_recurssion1 complete!\n"); PostOrderTraverse_recurssion2(T, vi); printf("\n"); printf("PostOrderTraverse_recurssion2 complete!\n"); printf("\n%c的双亲是%c, 长子是%c,下一个兄弟是%c\n", e1, Parent(T, e1),\ LeftChild(T, e1), RightSibling(T, e1)); printf("层序遍历树:\n"); LevelOrderTraverse(T, vi); DestroyTree(&T); return EXIT_SUCCESS; }
// 1 // \ // 2 // \ // 3 // \ // 4 // \ // 5 void TestC() { BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1); BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2); BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3); BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4); BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5); ConnectTreeNodes(pNode1, nullptr, pNode2); ConnectTreeNodes(pNode2, nullptr, pNode3); ConnectTreeNodes(pNode3, nullptr, pNode4); ConnectTreeNodes(pNode4, nullptr, pNode5); Test("TestC0", pNode1, 0, true, -1); Test("TestC1", pNode1, 1, false, 1); Test("TestC2", pNode1, 2, false, 2); Test("TestC3", pNode1, 3, false, 3); Test("TestC4", pNode1, 4, false, 4); Test("TestC5", pNode1, 5, false, 5); Test("TestC6", pNode1, 6, true, -1); DestroyTree(pNode1); printf("\n\n"); }