void main()
{
int i;
PTree T,p;
TElemType e,e1;
InitTree(T);
printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T));
CreateTree(T);
printf("构造树T后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T));
printf("层序遍历树T:\n");
TraverseTree(T,vi);
printf("请输入待修改的结点的值 新值: ");
scanf("%c%*c%c%*c",&e,&e1);
Assign(T,e,e1);
printf("层序遍历修改后的树T:\n");
TraverseTree(T,vi);
printf("%c的双亲是%c,长子是%c,下一个兄弟是%c\n",e1,Parent(T,e1),LeftChild(T,e1),RightSibling(T,e1));
printf("建立树p:\n");
InitTree(p);
CreateTree(p);
printf("层序遍历树p:\n");
TraverseTree(p,vi);
printf("将树p插到树T中，请输入T中p的双亲结点 子树序号: ");
scanf("%c%d%*c",&e,&i);
InsertChild(T,e,i,p);
Print(T);
printf("删除树T中结点e的第i棵子树，请输入e i: ");
scanf("%c%d",&e,&i);
DeleteChild(T,e,i);
Print(T);
}
int TreeDepth(Node* pRoot)
{
if (nullptr == pRoot)
return 0;
else
return 1 + max(TreeDepth(pRoot->pLeft), TreeDepth(pRoot->pRight));
}
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;
}
int TreeDepth(TreeNode* pRoot)
{
if (!pRoot) return 0;
int nLeft = TreeDepth(pRoot->left);
int nRight = TreeDepth(pRoot->right);
return nLeft > nRight ? nLeft + 1 : nRight + 1;
}
bool TreeBalance(TreeElem *Tree)
{
if (Tree != NULL)
{
bool res = (abs(TreeDepth(Tree->LeftSon) - TreeDepth(Tree->RightSon)) <= 1);
return res && TreeBalance(Tree->LeftSon) && TreeBalance(Tree->RightSon);
}
else
return true;
}
int TreeDepth(TreeNode* pRoot)
{
if (pRoot == NULL)
return 0;
int nLeftDepth = TreeDepth(pRoot->left);
int nRightDepth = TreeDepth(pRoot->right);
return (nLeftDepth>nRightDepth)?(nLeftDepth+1):(nRightDepth+1);
}
// ====================方法1====================
int TreeDepth(BinaryTreeNode* pRoot)
{
if(pRoot == NULL)
return 0;
int nLeft = TreeDepth(pRoot->m_pLeft);
int nRight = TreeDepth(pRoot->m_pRight);
return (nLeft > nRight) ? (nLeft + 1) : (nRight + 1);
}
int TreeDepth(TreeElem *Tree)
{
if (Tree != NULL)
{
int res = 0, a = TreeDepth(Tree->LeftSon), b = TreeDepth(Tree->RightSon);
if (a >= b)
return ++a;
else
return ++b;
}
else
return 0;
}
bool IsBalanced_Solution1(BinaryTreeNode* pRoot)
{
if(pRoot == NULL)
return true;
int left = TreeDepth(pRoot->m_pLeft);
int right = TreeDepth(pRoot->m_pRight);
int diff = left - right;
if(diff > 1 || diff < -1)
return false;
return IsBalanced_Solution1(pRoot->m_pLeft)
&& IsBalanced_Solution1(pRoot->m_pRight);
}
int TreeDepth(CSTree T)
{
int max,l;
if(T==NULL)
return 0;
else
{
max=0;
max=TreeDepth(T->firstchild);
l=TreeDepth(T->rightsibling);
if(l>max)
max=l;
return max+1;
}
}
void FindSum(Node* pNode, int nTargetSum)
{
int nDepth = TreeDepth(pNode);
vector< int > path(nDepth, 0);
FindSum(pNode, path, nTargetSum, 0);
}
vector<vector<int> > levelOrderBottom(TreeNode *root) {
int depth = TreeDepth(root);
vector<vector<int> > lot(depth);
if(root == NULL)
return lot;
queue<TreeNode *> nodeQueue;
nodeQueue.push(root);
TreeNode *node;
queue<int> levelQueue;
int level = 0;
levelQueue.push(level);
while(!nodeQueue.empty()){
node = nodeQueue.front();
nodeQueue.pop();
level = levelQueue.front();
levelQueue.pop();
lot[depth - level -1].push_back(node->val);
if(node->left){
nodeQueue.push(node->left);
levelQueue.push(level+1);
}
if(node->right){
nodeQueue.push(node->right);
levelQueue.push(level+1);
}
level++;
}
return lot;
}
void main()
{
int i;
CSTree T, p, q;
TElemType e, e1;
InitTree(T);
printf("构造空树后，树空否？%d(1：是 0：否)。树根为%c，树的深度为%d。\n",
TreeEmpty(T), Root(T), TreeDepth(T));
CreateTree(T);
printf("构造树T后，树空否？%d(1：是 0：否)。树根为%c，树的深度为%d。\n",
TreeEmpty(T), Root(T), TreeDepth(T));
printf("层序遍历树T：\n");
LevelOrderTraverse(T, visit);
printf("请输入待修改的结点的值 新值：");
scanf("%c%*c%c%*c", &e, &e1);
Assign(T, e, e1);
printf("层序遍历修改后的树T：\n");
LevelOrderTraverse(T, visit);
printf("%c的双亲是%c，长子是%c，下一个兄弟是%c。\n", e1, Parent(T, e1),
LeftChild(T, e1), RightSibling(T, e1));
printf("建立树p：\n");
CreateTree(p);
printf("层序遍历树p：\n");
LevelOrderTraverse(p, visit);
printf("将树p插到树T中，请输入T中p的双亲结点 子树序号：");
scanf("%c%d%*c", &e, &i);
q = Point(T, e);
InsertChild(T, q, i, p);
printf("层序遍历修改后的树T：\n");
LevelOrderTraverse(T, visit);
printf("先根遍历树T：\n");
PreOrderTraverse(T, visit);
printf("\n后根遍历树T：\n");
PostOrderTraverse(T, visit);
printf("\n删除树T中结点e的第i棵子树，请输入e i：");
scanf("%c%d", &e, &i);
q = Point(T, e);
DeleteChild(T, q, i);
printf("层序遍历修改后的树T：\n");
LevelOrderTraverse(T, visit);
DestroyTree(T);
}
int main()
{
const char *preOrder = "ABEHGCDFIJ";
const char *inOrder = "BHEGADCIFJ";
Bitree tree = InitTree(preOrder, inOrder);
printf("back order: %s\n", CalcBackSequence(preOrder, inOrder));
PreOrderTraverseRecursive(tree);
printf("\n");
PreOrderTraverseNonRecursive(tree);
printf("\n");
InOrderTraverseRecursive(tree);
printf("\n");
InOrderTraverseNonRecursive(tree);
printf("\n");
BackOrderTraverseRecursive(tree);
printf("\n");
BackOrderTraverseRecursive(tree);
printf("\n");
LayerOrderTraverse(tree);
printf("\n");
LayerOrderTraverse2(tree);
printf("\n");
printf("Layer0: ");
TraverseLayer(tree, 0);
printf("\n");
printf("Layer3: ");
TraverseLayer(tree, 3);
printf("\n");
printf("Layer5: ");
TraverseLayer(tree, 5);
printf("\n");
printf("tree depth: %d\n", TreeDepth(tree));
BitreeNode *parent = NearestParent(tree, 'D', 'J');
if(parent)
printf("nearest parent: %c\n", parent->data);
printf("longest path in tree: %d\n", LongestPath(tree));
printf("longest path in tree->rchild: %d\n", LongestPath(tree->rchild));
return 0;
}
struct BinaryTreeNode{
int value;
BinaryTreeNode* p_left;
BinaryTreeNode* p_right;
}
int TreeDepth(BinaryTreeNode* pRoot){
if(pRoot == NULL)
return 0;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
return (left > right) ? (left + 1) : (right + 1);
}
// ==================== Test Code ====================
void Test(char* testName, BinaryTreeNode* pRoot, int expected)
{
if(testName != NULL)
printf("%s begins: ", testName);
int result = TreeDepth(pRoot);
if(expected == result)
printf("Test passed.\n");
else
printf("Test failed.\n");
}
int TreeDepth(CBTType *treeNode) //计算二叉树深度
{
int depleft,depright;
if(treeNode == NULL)
{
return 0; //对于空树，深度为0
}
else
{
depleft = TreeDepth(treeNode->left); //左子树深度（递归调用）
depright = TreeDepth(treeNode->right); //右子树深度（递归调用）
if(depleft>depright)
{
return depleft +1;
}
else{
return depright + 1;
}
}
}
int TreeDepth(CSTree T)
{
CSTree p;
int depth, max = 0;
if (!T)
return 0;
for (p = T->firstchild; p; p = p->nextsibling) {
depth = TreeDepth(p);
if (depth > max)
max = depth;
}
return max + 1;
}
void main()
{
int i;
CSTree T,p,q;
TElemType e,e1;
InitTree(&T);
printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T));
CreateTree(&T);
printf("构造树T后,树空否? %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(T,vi);
printf("\n%c的双亲是%c,长子是%c,下一个兄弟是%c\n",e1,Parent(T,e1),LeftChild(T,e1),RightSibling(T,e1));
printf("建立树p:\n");
InitTree(&p);
CreateTree(&p);
printf("层序遍历树p:\n");
LevelOrderTraverse(p,vi);
printf("\n将树p插到树T中，请输入T中p的双亲结点 子树序号: ");
scanf("%c%d%*c",&e,&i);
q=Point(T,e);
InsertChild(&T,q,i,p);
printf("层序遍历树T:\n");
LevelOrderTraverse(T,vi);
printf("\n删除树T中结点e的第i棵子树，请输入e i: ");
scanf("%c%d",&e,&i);
q=Point(T,e);
DeleteChild(&T,q,i);
printf("层序遍历树T:\n",e,i);
LevelOrderTraverse(T,vi);
printf("\n");
DestroyTree(&T);
}
void KrTile::Draw( KrPaintInfo* paintInfo, const KrRect& clip )
{
GLASSERT( IsVisible() );
if ( bounds.Intersect( clip ) )
{
resource->Draw( paintInfo,
CompositeXForm(),
rotation,
CompositeCForm(),
clip,
CompositeQuality(),
TreeDepth() );
}
}
static int TreeDepth(CSTree T)
{ // 初始条件: 树T存在。操作结果: 返回T的深度
CSTree p;
int depth,max=0;
if(!T) // 树空
return 0;
if(!T->firstchild) // 树无长子
return 1;
for(p=T->firstchild;p;p=p->nextsibling)
{
depth=TreeDepth(p);
if(depth>max)
max=depth;
}
return max+1;
}
int TreeDepth(CSTree T)
{ /* 初始条件: 树T存在。操作结果: 返回T的深度 */
CSTree p;
int depth,max=0;
if(!T) /* 树空 */
return 0;
if(!T->firstchild) /* 树无长子 */
return 1;
for(p=T->firstchild;p;p=p->nextsibling)
{
depth=TreeDepth(p);
if(depth>max)
max=depth;
}
return max+1;
}
int main(int argc,char *argv[])
{
int i;
TElemType e,tempe;
PTree T,C;
InitTree(T);
InitTree(C);
printf("������:");
CreateTree(T);
CreateTree(C);
printf("\n������:");
TraverseTree(T,Visit);
printf("\n");
TraverseTree(C,Visit);
printf("\n����:%c",Root(T));
printf("\n����i:");
scanf("%d%*c",&i);
printf("\n��ֵ:%c",(tempe=Value(T,i)));
printf("\n��ֵ:");
scanf("%c%*c",&e);
Assign(T,tempe,e);
printf("\n���ڵ㡢���ӡ����ֵܣ��������:%c %c %c %d %d",
Value(T,Parent(T,e)),
Value(T,LeftChild(T,e)),Value(T,RightSibling(T,e)),
TreeDepth(T),TreeEmpty(T));
printf("\n��������:");
InsertChild(T,e,1,C);
TraverseTree(T,Visit);
printf("\nɾ�������:");
DeleteChild(T,e,1);
TraverseTree(T,Visit);
DestroyTree(T);
DestroyTree(C);
return 0;
}
void main()
{
CBTType *root=NULL;
char menusel;
void (*TreeNodeData1)(CBTType *p);
TreeNodeData1=TreeNodeData;
root = InitTree();
do{
printf("请选择菜单添加二叉树的节点\n");
printf("0.退出\t");
printf("1.添加二叉树的节点\n");
menusel = getch();
switch(menusel)
{
case '1':
AddTreeNode(root);
break;
case '0':
break;
default:
;
}
}while(menusel != '0');
do{
printf("请选择菜单遍历二叉树，输入0表示退出：\n");
printf("1.先序遍历DLR\t");
printf("2.中序遍历LDR\n");
printf("3.后序遍历LRD\t");
printf("4.按层遍历\n");
menusel = getch();
switch(menusel)
{
case '0':
break;
case '1':
printf("\n 先序遍历DLR的结果：");
DLRTree(root,TreeNodeData1);
printf("\n");
break;
case '2':
printf("\n中序遍历LDR的结果：");
LDRTree(root,TreeNodeData1);
printf("\n");
break;
case '3':
printf("\n 后序遍历LRD的结果：");
LRDTree(root,TreeNodeData1);
printf("\n");
break;
case '4':
printf("\n 按层遍历的结果：");
LevelTree(root,TreeNodeData1);
printf("\n");
break;
default:
;
}
}while(menusel != '0');
printf("\n 二叉树深度为：%d \n",TreeDepth(root));
ClearTree(root);
root = NULL;
}
int TreeDepth(TreeNode* pRoot)
{
if (pRoot == NULL) return 0;
return 1 + max(TreeDepth(pRoot->left), TreeDepth(pRoot->right));
}
cisstCovTree_Mesh::cisstCovTree_Mesh(cisstMesh &mesh, int countThresh, double diagThresh)
: MeshP(&mesh)
{
NData = MeshP->NumTriangles();
DataIndices = new int[NData];
for (int i = 0; i < NData; i++)
{
DataIndices[i] = i;
}
Top = new cisstCovTreeNode(DataIndices, NData, this, NULL);
NNodes = 0; NNodes++;
treeDepth = Top->ConstructSubtree(countThresh, diagThresh);
#ifdef DebugCovTree
fprintf(debugFile, "Mesh Cov Tree built: NNodes=%d NData=%d TreeDepth=%d\n", NumNodes(), NumData(), TreeDepth());
#endif
}
// Build tree from point cloud input
// this constructor does not define the noise model for the point cloud;
// the user must do this manually by calling the noise model methods of this class
PDTree_PointCloud::PDTree_PointCloud(
cisstPointCloud &pointCloud,
int nThresh,
double diagThresh ) :
pointCloud(pointCloud)
{
NData = pointCloud.points.size();
DataIndices = new int[NData];
for (int i = 0; i < NData; i++)
{
DataIndices[i] = i;
}
Top = new PDTreeNode(DataIndices, NData, this, NULL);
NNodes = 0; NNodes++;
treeDepth = Top->ConstructSubtree(nThresh, diagThresh);
#ifdef DEBUG_PD_TREE
fprintf(debugFile, "Point Cloud Cov Tree built: NNodes=%d NData=%d TreeDepth=%d\n", NumNodes(), NumData(), TreeDepth());
#endif
}
