在平衡树中获取节点父节点的索引，传递其索引

Question

示例：

我有以下示例，说明冠军赛时间表：

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

规则：

数字代表节点的值（匹配）。值从上到下开始，因为根是冠军的最后一场比赛。

树将始终保持平衡，并且可以有 N 个顶部位置，其中 N = {2,4,8,16,32,64,128,256...}

问题：

我需要找到一个数学函数，它会返回节点父节点的值，并传递它的值。而且这个数学函数必须可以用 C# 来表示。

GetNodeParent(9); // must return 13
GetNodeParent(10); // must return 13
GetNodeParent(4); // must return 10
GetNodeParent(15); // must return null

功能应该如何？

Answer 1

在我看来，处理此问题的最简单方法是将您的树以相反的方式存储。通常，平衡树可以在一个数组中表示，其中根位于第一个位置，叶子位于最后一个 n/2 位置，如下所示：

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

在内存中看起来像这样：

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

现在这个构造的一个有趣属性是，父级总是在Math.Floor(index/2)（所以子级在n*2 和n*2+1）

例如，13 的父级是 13/2 = 6.5 =floored= 6。它确实简化了操作。

如前所述，所有叶子节点都在最后 n/2 个位置。这是另一个有趣的命运。如果您正在寻找第一轮比赛，只需砍掉您的数组并取出 Math.Ceiling(n/2) 最后一项：

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

对于第二轮，删除前一轮并在Math.Ceiling(n/2) 再次切碎：

1|2|3|4|5|6|7|

---

所以知道这一点，GetParent 可以如下所示：

public static int? GetParent(int childIndex)
{
    int parentIndex = (int) Math.Floor((double)childIndex/2);
    return parentIndex == 0 ? (int?)null : parentIndex;
}

如果您不需要空值，请直接return (int)Math.Floor((double)index/2);。

这可以通过根据您的示例值的位置进行的简单单元测试来验证：

[TestMethod]
public void TestMethod1()
{
    Assert.AreEqual(2, Stuff.GetParent(4));
    Assert.AreEqual(2, Stuff.GetParent(5));
    Assert.AreEqual(6, Stuff.GetParent(13));
    Assert.AreEqual(null, Stuff.GetParent(1));
}

而且不要忘记使用索引而不是值，您不能直接应用 9 并从示例中获取 13，现在是 4 和 2，因为这是它们在树中的索引，根在第一个位置，其构造类似。您提供的示例将是这样构造的：

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

如果您需要按价值观工作，可以使用IndexOf。由于您是基于 1 而不是基于 0，因此您还需要将 1 添加到每个索引。看起来像这样：

    [TestMethod]
    public void TestMethod1()
    {
        List<int> values = new List<int>{15, 13, 14, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8};

        Assert.AreEqual(values.IndexOf(13) + 1, Stuff.GetParent(values.IndexOf(9) + 1));
        Assert.AreEqual(values.IndexOf(13) + 1, Stuff.GetParent(values.IndexOf(10) + 1));
        Assert.AreEqual(values.IndexOf(10) + 1, Stuff.GetParent(values.IndexOf(4) + 1));
        Assert.AreEqual(null, Stuff.GetParent(values.IndexOf(15)));
    }

Answer 2

选项 1：构建一个相反的新树，因此您可以使用二叉树。

---

选项 2：

请致电list_name.Count()，我为您使用了 15 个

GetNodeParent(9,15); // return 13
GetNodeParent(10,15);// return 13
GetNodeParent(4,15); // return 10

这可行，但您必须检查最终情况（在您的情况下为 15 个）：

int GetNodeParent(int aNodeValue, int aListSize) {
    aNodeValue.Dump("Look for the parent of");
    var depth = (int)(Math.Log(aListSize,2) ); // this rounds down
    var level = Math.Pow(2,depth);
    while (aNodeValue > level) {
        depth--;
        level += Math.Pow(2,depth);
    }
    var target = level+1;   // this will be our accumulator
    var search = level;     // for our "binary search"
    var search_width = Math.Pow(2,depth).Dump("width");
    // This runs a "binary search", adding 1 to our result
    // if we are on the right side.
    while (search_width!=0){
       if (aNodeValue > level)
            target++;
        search -= search_width / 2;
        search_width /=2;
    }       

    return (int)target;
}

事后考虑，在调用方法之前添加一个if (aNodeValue == list_name.Count())，对于null，或者将签名更改为int?，然后在方法中进行检查，这样它就会返回null

Answer 3

你试过这个简单的公式吗？

GetNodeParent(k) = (k + 1) div 2 + N
(if >=2N then null)

其中 div 是整数除法 (7 div 2 = 3)