写一个算法，实现遍历树的所有节点（可用深度优先搜索或广度优先搜索）

2016-09-12 04:26:56 593 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

数据结构之树：深度优先搜索和广度优先搜索的应用树是一种由若干个节点和连接这些节点的边组成的结构。节点：树中的每个元素。边：连接节点的线。根节点：树的最顶层节点，没有父节点。叶子节点：没有子节点的节点。父子节点关系：每个节点有一个父节点，可以有多个子节点。子树：以某一节点为根节点的树。深度：从根节点到当前节点的路径长度。高度：从当前节点到最远叶子节点的路径长度。DFS 和 BFS 是树的遍历算法中最常见的两种搜索策略，它们各自有不同的优缺点，适用于不同的应用场景。阅读详情

广度的

void levelorder(Node *root) {
if (root == NULL) {
return;
}
queue<Node *> nodeQ;
nodeQ.push(root);

while (!nodeQ.empty()) {
Node *node = nodeQ.front();
nodeQ.pop();
operate(node);

// push children if exist
if (node->left != NULL) {
nodeQ.push(node->left);
}
if (node->right != NULL) {
nodeQ.push(node->right);
}
}
}

看看对不对，错的请帮忙改改，拜托了

...全文

十大基础实用算法之深度优先搜索和广度优先搜索深入讲解了深度优先和广度优先算法的实现，有详细的图解实例以及代码实现，清晰易懂。使用类的思想实现代码，面向对象分析。阅读详情

qq_35328580

C# 111,128 成员 642,536 内容

+ 关注 + 加入社区

切换为时间正序

贝爷_野外求生 2016-09-13

打赏
举报

还不懂什么是广度、深度手里有个查找node的递归方法，希望能用得上

/// <summary>遍历查找节点
        /// 
        /// </summary>
        /// <param name="tnParent">一级节点</param>
        /// <param name="strValue">查找关键字</param>
        /// <returns>返回找到的第一个节点</returns>
        private TreeNode FindNode(TreeNode tnParent, string strValue)
        {
            if (tnParent == null)
                return null;
            if (tnParent.Text == strValue)
                return tnParent;
            TreeNode resultNode = null;
            foreach (TreeNode node in tnParent.Nodes)
            {
                resultNode = FindNode(node, strValue);
                if (resultNode != null) 
                    break; //如果要继续查找，这里调整下
            }
            return resultNode;
        }

以专业开发人员为伍 2016-09-13

打赏
举报

嗯，给你改成你那种“n叉分支树”的结构

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var xx = new A { Value = "1" };
            xx.Children.Add(new A { Value = "2" });
            xx.Children.Add(new A { Value = "3" });
            xx.Children[0].Children.Add(new A { Value = "4" });
            xx.Children[0].Children.Add(new A { Value = "5" });
            xx.Children[1].Children.Add(new A { Value = "6" });
            xx.Children[1].Children.Add(new A { Value = "7" });
            foreach (var x in 深度优先搜索(xx))
                Console.Write("{0} ", x.Value);
            Console.WriteLine();
            foreach (var x in 宽度优先搜索(xx))
                Console.Write("{0} ", x.Value);
            Console.WriteLine();
            Console.WriteLine("................按任意键结束");
            Console.ReadKey();
        }

        static private IEnumerable<A> 宽度优先搜索(A xx)
        {
            return 宽度优先搜索(new List<A> { xx });
        }

        static private IEnumerable<A> 宽度优先搜索(List<A> list)
        {
            if (list.Count > 0)
            {
                var 下一层 = new List<A>();
                foreach (var x in list)
                {
                    yield return x;
                    下一层.AddRange(x.Children);
                }
                foreach (var x in 宽度优先搜索(下一层))
                    yield return x;
            }
        }

        static private IEnumerable<A> 深度优先搜索(A xx)
        {
            yield return xx;
            foreach (var x in xx.Children)
                foreach (var y in 深度优先搜索(x))
                    yield return y;
        }
    }

    public class A
    {
        public string Value;
        public List<A> Children = new List<A>();
    }
}

你可以看到，宽度优先搜索，要重载函数，将参数改为“集合”方式，以便一层层地访问节点。

以专业开发人员为伍 2016-09-13

打赏
举报

这里是以二叉树举例。对于分支为n个情况，其实算法是完全一样的。

以专业开发人员为伍 2016-09-13

打赏
举报

给你写了个例子，包含简单测试：

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var xx = new A { Value = "1" };
            xx.Left = new A { Value = "2" };
            xx.Right = new A { Value = "3" };
            xx.Left.Left = new A { Value = "4" };
            xx.Left.Right = new A { Value = "5" };
            xx.Right.Left = new A { Value = "6" };
            xx.Right.Right = new A { Value = "7" };
            foreach (var x in 深度优先搜索(xx))
                Console.Write("{0} ", x.Value);
            Console.WriteLine();
            foreach (var x in 宽度优先搜索(xx))
                Console.Write("{0} ", x.Value);
            Console.WriteLine();
            Console.WriteLine("................按任意键结束");
            Console.ReadKey();
        }

        static private IEnumerable<A> 宽度优先搜索(A xx)
        {
            return 宽度优先搜索(new List<A> { xx });
        }

        static private IEnumerable<A> 宽度优先搜索(List<A> list)
        {
            if (list.Count > 0)
            {
                var 下一层 = new List<A>();
                foreach (var x in list)
                    if (x != null)
                    {
                        yield return x;
                        下一层.Add(x.Left);
                        下一层.Add(x.Right);
                    }
                foreach (var x in 宽度优先搜索(下一层))
                    yield return x;
            }
        }

        static private IEnumerable<A> 深度优先搜索(A xx)
        {
            yield return xx;
            if (xx.Left != null)
                foreach (var x in 深度优先搜索(xx.Left))
                    yield return x;
            if (xx.Right != null)
                foreach (var x in 深度优先搜索(xx.Right))
                    yield return x;
        }
    }

    public class A
    {
        public string Value;
        public A Left;
        public A Right;
    }
}

qq_35328580 2016-09-12

打赏
举报

能帮我改改吗

娃都会打酱油了 2016-09-12

打赏
举报

递归递归递归没了……

写一个算法，实现遍历树的所有节点（可用深度优先搜索或广度优先搜索）

相关推荐