Chinaunix首页 | 论坛 | 博客
  • 博客访问: 729399
  • 博文数量: 79
  • 博客积分: 2671
  • 博客等级: 少校
  • 技术积分: 1247
  • 用 户 组: 普通用户
  • 注册时间: 2010-04-02 15:26
个人简介

宅男

文章分类

全部博文(79)

文章存档

2017年(11)

2016年(12)

2015年(6)

2012年(10)

2011年(33)

2010年(7)

分类: LINUX

2011-08-05 20:06:41

参考别人的代码,然后加入一点自己的理解吧,算法最主要的是理解,拷贝代码没用。
先根序
  1. /*===========================================================================
    * Function name:    BT_PreOrder
    * Parameter:        root:树根节点指针
    * Precondition:        None
    * Description:        前序遍历
    * Return value:        void
    * Author:            Liu Qi,  [12/29/2005]
    ====================================================================
  2. void BT_PreOrder(pTreeT root)
  3. {
  4.     if (NULL != root)
  5.     {
  6.         visit(root);
  7.         BT_PreOrder(root->left);
  8.         BT_PreOrder(root->right);
  9.     }
  10. }
  11. //还是递归简单
  12. //但是我很讨厌递归这种算法,一方面是因为对于stack的消耗,另外一点就是递归容易将脑子搞糊涂
  1. /*===========================================================================
  2. * Function name: BT_PreOrderNoRec
  3. * Parameter: root:树根节点指针
  4. * Precondition: Node
  5. * Description: 前序(先根)遍历非递归算法
  6. * Return value: void
  7. * Author: Liu Qi, [1/1/2006]
  8. ===========================================================================*/
  9. void BT_PreOrderNoRec(pTreeT root)
  10. {
  11.     stack<treeT *> s;

  12.     while ((NULL != root) || !s.empty())
  13.     {
  14.         if (NULL != root)
  15.         {
  16.             visit(root);
  17.             s.push(root);
  18.             root = root->left;
  19.         }
  20.         else
  21.         {
  22.             root = s.top();
  23.             s.pop();
  24.             root = root->right;
  25. //原来理解错误了,以为这儿应该改为root = s.top()->right.
  26. //发现非递归遍历二叉树都是采用了kunth的借助辅助栈的方法
  27. //所谓先根序即先访问左节点,再访问根节点,最后是右节点,这儿的根借用“树”的递归概念,并不是指二叉树树的根
  28. //而是一个只有父节点,左右节点的节点(当然左右节点可以为空)如下图所示,所谓的二叉树就是由这样的子树组成的。
  29. //由于是先根序,那么一个stack中每一个节点必然已经被访问过了,但是这些节点的右子树没有被访问
  30.         }
  31.     }
  32. }

中根序
  1. /*===========================================================================
  2. * Function name: BT_InOrder
  3. * Parameter: root:树根节点指针
  4. * Precondition: None
  5. * Description: 中序遍历
  6. * Return value: void
  7. * Author: Liu Qi, [12/30/2005]
  8. ===========================================================================*/
  9. void BT_InOrder(pTreeT root)
  10. {
  11.     if (NULL != root)
  12.     {
  13.         BT_InOrder(root->left);
  14.         visit(root);
  15.         BT_InOrder(root->right);
  16.     }
  17. }

  1. void BT_InOrderNoRec(pTreeT root)
  2. {
  3.     stack<treeT *> s;
  4.     while ((NULL != root) || !s.empty())
  5.     {
  6.         if (NULL != root)
  7.         {
  8.             s.push(root);
  9.             root = root->left;//一路压栈到底
  10.         }
  11.         else
  12.         {
  13.             root = s.top();//在退栈的时候访问,
  14.             visit(root);
  15.             s.pop();
  16.             root = root->right;
  17.         }
  18.     }
  19. }
InOrderTraverse(BiTree T)
{
InitStack(S);Push(S,T);
while(!StackEmpty(S)){
While(GetTop(S,p) && p)
Push(S,p->left);//向左走到尽头,然后开始退栈
Pop(S,p);//将最后一个空指针退栈
if(!StackEmpty(S)){
Pop(S,p);
Visit(p);
Push(S,p->right);//将右节点压栈,然后准备再一次向左走到尽头。
}
}
对于中根序,栈中的每一个节点必然是没有被访问过的,都是等待到退栈的时候访问的。
但是如果仔细的话会发现,访问的第一个节点必然是从二叉树的根一路向左访问的最后一个节点。那么有人就会疑惑,为什么访问的是一个左节点,却叫中根序呢?其实从上图任然可以看出,这个左节点的两个孩子都是空指针,所以它任然是一个根。
阅读(1141) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~