算法笔记(有根树遍历)

 public class TreeNode
    {
        public string Key { get; set; }
        public object Data { get; set; }
        public TreeNode Parent;
        public List<TreeNode> Children { get; set; }
        public TreeNode(string Key,object Data)
        {
            Children = new List<TreeNode>();
            this.Key = Key;
            this.Data = Data;
        }
        public void AddChild(TreeNode node)
        {
            this.Children.Add(node);
            node.Parent = this;
        }
        public void DelChild(TreeNode node)
        {
            this.Children.Remove(node);
        }
    }
    public class Trees
    {
        public TreeNode Root { get; set; }
        /// <summary>
        /// 非递归遍历树方法，这里采用的先父后子的顺序遍历.如果要先子后父的话，则需要用到两个栈，两个循环.
        /// </summary>
        /// <param name="ListCurrNode"></param>
        public void ListChildren(Action<TreeNode> ListCurrNode)
        {
            if (Root == null)
            {
                return;
            }
            //先父后子
            Stack<TreeNode> _nodesStack1 = new Stack<TreeNode>();
            while (_nodesStack1.Count > 0)
            {
                TreeNode node = _nodesStack1.Pop();
                ListCurrNode(node);
                foreach (var item in node.Children)
                {
                    _nodesStack1.Push(item);
                }
            }
            //先子后父.其实对于二叉树的左序和右序访问，也需要两个栈来实现.
            _nodesStack1.Clear();
            _nodesStack1.Push(Root);
            Stack<TreeNode> _nodesStack2 = new Stack<TreeNode>();
            while (_nodesStack1.Count > 0)
            {
                TreeNode node = _nodesStack1.Pop();
                _nodesStack2.Push(node);
                foreach (var item in node.Children)
                {
                    _nodesStack1.Push(item);
                }
            }
            while (_nodesStack2.Count > 0)
            {
                TreeNode node = _nodesStack1.Pop();
                ListCurrNode(node);
            }
        }

        /// <summary>
        /// 非递归中序，线性时间，常数额外辅助空间方式，不能修改树（临时的也不行），可以遍历任意的叉树.对于K叉树，每次退回的比较时间为<=K,
        /// 因为每个节点至多需退回一次，则退回比较为<=Kn次,树遍历本身的O(n).遍历还是线性时间。
        /// 其实如果可以修改树，比如设置访问标志，则直接可以退回，然后继续访问第1个未访问的子节点。
        /// 下面的算法其实就是利用这种思想，只是不是直接设置标志，而是利用了数组指针的特性。
        /// 对于左子右兄弟的表达是任意叉树也可以实现，只是退回遍历方法不同而已(更简单).
        /// 如果采用的是K个孩子指针变量的表示孩子节点的方式，也是适用的，只是需要默认一个访问逻辑顺序即可.
        /// 注意：这里其实采用的是先父后子的访问顺序，如果需要先子后父，也是可以的，需要增加一个子访问完成退回标记，稍稍修改
        /// 一下代码即可.
        /// </summary>
        /// <param name="ListCurrNode">遍历访问者</param>
        public void ListAll1(Action<TreeNode> ListCurrNode)
        {
            int theQuitFrom = -1;//-1表示从父节点来,0-n表示从第k个孩子回来.
            TreeNode theCurrNode = Root;
            while (theCurrNode != null)
            {
                TreeNode theTmp = null;
                if (theQuitFrom < 0)//刚从父节点过来(theQuitFrom=-1)
                {
                    ListCurrNode(theCurrNode);
                    //从父节点过来时，访问第1个孩子(索引为0).
                    if (theCurrNode.Children.Count > 0)
                    {
                        theTmp = theCurrNode.Children[0];
                    }
                    else
                    {
                        theTmp = null;
                    }
                }
                else //从孩子节点遍历退回来，则去下一个孩子节点。
                {
                    if (theQuitFrom + 1 < theCurrNode.Children.Count)
                    {
                        theTmp = theCurrNode.Children[theQuitFrom + 1];
                        theQuitFrom = -1;
                    }
                    else//孩子节点访问完成，theTmp置空，继续执行后退策略.
                    {
                        theTmp = null;//如果要先子后父，需要在这里做标记
                    }
                }
                if (theTmp == null) //如果theTmp为空，则表示无法继续向下遍历，需后退访问兄弟节点
                {
                    //如果当前节点是root，表示已经需从root退回,则表示整个树遍历完成，
                    //这里也保证了GetChildrenIndex不会返回-1的情况.
                    if (theCurrNode == Root)
                        break;
                    theQuitFrom = GetChildrenIndex(theCurrNode.Parent, theCurrNode);
                    theCurrNode = theCurrNode.Parent;
                }
                else //不为空，则将theTmp节点作为当前节点进行访问。
                {
                    //这种情况下,theQuitFrom一定是-1.因为初始为-1，只有退回的时候才会改变这个值，
                    //如果退回有下一个兄弟可访问,则theQuitFrom一定会被设置为-1,如果没有，则只能继续
                    //退.如果能继续访问,theQuitFrom一定保持着-1.
                    theCurrNode = theTmp;
                }
            }

        }
        /// <summary>
        /// 获取孩子节点在父节点中的位置.
        /// </summary>
        /// <param name="Parent"></param>
        /// <param name="Child"></param>
        /// <returns></returns>
        private int GetChildrenIndex(TreeNode Parent, TreeNode Child)
        {
            for (int i = 0; i < Parent.Children.Count; i++)
            {
                if (Parent.Children[i] == Child)
                {
                    return i;
                }
            }
            //实际上这里放回-1是没法执行的.
            return -1;
        }
    }

本文参考了CSDN网友的文章： http://blog.csdn.net/acrazer/article/details/4454508