关于C#：如何在树中查找下一个元素

How to find the next element in the tree

我有一棵如下树：

1
2
3
4
5
6
7

/* Tree
* 5
* / \\
* 3 1
* / \\ / \\
* 2 4 6 7
*/

我正在使用名为Node的类创建此树，如下所示：

1
2
3
4
5
6
7
8
9
10

var root = new Node(
5,
new Node(
3,
new Node(2),
new Node(4)),
new Node(
1,
new Node(6),
new Node(7)));

因此，我希望打印出有序的树：1 2 3 4 5 6 7。
我可以找到参考此示例的下一个更大的元素https://www.geeksforgeeks.org/next-larger-element-n-ary-tree/，但是我无法找到如何打印其中的所有节点订单。

编辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

public static class Program
{
static void Main(string[] args)
{
var root = new Node(
5,
new Node(
3,
new Node(2),
new Node(4)),
new Node(
1,
new Node(6),
new Node(7)));

var n = root;

while (n != null)
{
Console.WriteLine(n.Data);
n = n.NextNode();
}
}

public static Node NextNode(this Node node)
{
var newNode = NextLargerElement(node, node.Data);

return newNode;
}

public static Node res;
public static Node NextLargerElementUtil(Node root, int x)
{
if (root == null)
return null;

if (root.Data > x)
if ((res == null || (res).Data > root.Data))
res = root;

foreach (var children in root.Children)
{
NextLargerElementUtil(children, x);
}

return res;
}

static Node NextLargerElement(Node root, int x)
{
res = null;

NextLargerElementUtil(root, x);

return res;
}
}

和Node类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class Node
{
private List<Node> _children;

public Node(int data, params Node[] nodes)
{
Data = data;
AddRange(nodes);
}

public Node Parent { get; set; }

public IEnumerable<Node> Children
{
get
{
return _children != null
? _children
: Enumerable.Empty<Node>();
}
}

public int Data { get; private set; }

public void Add(Node node)
{
//Debug.Assert(node.Parent == null);

if (_children == null)
{
_children = new List<Node>();
}

_children.Add(node);
node.Parent = this;
}

public void AddRange(IEnumerable<Node> nodes)
{
foreach (var node in nodes)
{
Add(node);
}
}

public override string ToString()
{
return Data.ToString();
}
}

相关讨论

您需要一个递归/迭代器函数来遍历所有分支并获取所有节点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public IEnumerable<Node> GetAllNodes(Node parent)
{
IEnumerable<Node> GetAllNodes(IEnumerable<Node> children)
{
foreach(var child in children)
{
yield return child;
foreach(var c in GetAllNodes(child.Children))
yield return c;
}
}

yield return parent;

foreach(var child in GetAllNodes(parent.Children))
yield return child;
}

如果您有一棵像这样的树：

1
2
3
4
5
6
7

var root = new Node(5,
new Node(3, new Node(11), new Node(12),
new Node(2),
new Node(4), new Node(13)),
new Node(1, new Node(14), new Node(15),
new Node(6, new Node(16), new Node(17)),
new Node(7, new Node(8), new Node(9))), new Node(10));

调用该函数，传递root节点，并通过Data属性订购：

1
2
3

var q = GetAllNodes(root).OrderBy(x => x.Data).Select(x => x.Data);

Console.WriteLine(string.Join(",", q));

输出为：

1	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17

最好使其成为Node类型的扩展方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

static class Extensions
{
public static IEnumerable<Node> GetAllNodes(this Node parent)
{
IEnumerable<Node> GetAllNodes(IEnumerable<Node> children)
{
foreach (var child in children)
{
yield return child;
foreach (var c in GetAllNodes(child.Children))
yield return c;
}
}

yield return parent;

foreach (var child in GetAllNodes(parent.Children))
yield return child;
}
}

因此您可以按以下方式调用它：

1
2
3

var q = root.GetAllNodes().OrderBy(x => x.Data).Select(x => x.Data);

Console.WriteLine(string.Join(",", q));