Ruby 在多维散列中获取父级

签出此多维哈希：

hash = { 
       A: { 
            name: 'A', children: {} 
       },
       B: { 
            name: 'B', children: {
                B1: {
                    name: 'B1', children: {
                        B1i: {
                           name: 'B1i', children: {}
                        },
                        B1ii: {
                           name: 'B1ii', children: {}
                        },
                        B1iii: {
                           name: 'B1iii', children: {}
                        },
                        B1iv: {
                           name: 'B1iv', children: {}
                        }
                    }, 
                },
            }, 
       },
       C: {
            name: 'C', children: {
                C1: {
                   name: 'C1', children: {}
                },
                C2: {
                   name: 'C2', children: {}
                }
            }, 
        },                
    } 

def is_a_child_of(parent, child)
   child.parent[:name] == parent ? true : false
end

hash.each do |key, f1|
    puts "F1 generation member: #{f1[:name]}"

    f1[:children].each do |key, f2|

        is_a_child_of('B2', f2)            

        puts "F2 generation member: #{f2[:name]}"

        f2[:children].each do |key, f3|
            puts "F3 generation member: #{f3[:name]}"
        end
    end
end #=>
#
# F1 generation member: A
# F1 generation member: B
# F2 generation member: B1
# F3 generation member: B1i
# F3 generation member: B1ii
# F3 generation member: B1iii
# F3 generation member: B1iv
# F1 generation member: C
# F2 generation member: C1
# F2 generation member: C2
#

找出每个“个人”父母最有效的方法是什么？以下是我希望使用的真实方法：

def is_a_child_of(parent, child)
   child.parent[:name] == parent ? true : false
end

但是，

child.parent

是完整的伪代码。我如何实现这个父方法

或者，简单地在每个循环中记录父循环是否更有效？更多伪代码：

hash.each_with_parent do |parent, key, value|
end

我如何实现这个

带父循环的每个循环

是否有一个选项可以简单地在每个哈希中保存父项

e、 g

    B: { 
        name: 'B', children: {
            B1: {
                name: 'B1', parent: 'B', children: {}
            }
        } 
    }

每个哈希都不知道它所在的上下文。一种方法是在整个结构中搜索子结构，记住在哪里找到它，然后使用它来查找父结构。另一个是，正如您所说的，将父项存储在每个记录中。哪种方法最适合您取决于您有多少记录，您希望使用多少额外空间来记录显式父项，以及您希望花多少时间在数据结构上寻找父项

您可能需要查看一些图形库，了解如何存储这种数据结构。
您需要实现某种树结构，其中子节点跟踪其父节点

这是跟踪孩子和家长的树的简单实现：

class Tree < Hash
  def initialize(hash = {})
    replace build_tree(hash)
  end

  private

  def build_tree(hash, parent: :root)
    hash.inject({}) do |h,(k,v)|
      h[k] = {
        parent: parent,
        value:  v.kind_of?(Hash) ? build_tree(v, parent: k) : v
      }; h
    end
  end
end

require 'yaml'
puts Tree.new({
  A: {
    A1: 'asdf',
    A2: 'qwer'
  },
  B: {
    B1: {
      B1i: 'uiop',
      B1ii: 'zxcv'
    }
  }
}).to_yaml

--- !ruby/hash:Tree
:A:
  :parent: :root
  :value:
    :A1:
      :parent: :A
      :value: asdf
    :A2:
      :parent: :A
      :value: qwer
:B:
  :parent: :root
  :value:
    :B1:
      :parent: :B
      :value:
        :B1i:
          :parent: :B1
          :value: uiop
        :B1ii:
          :parent: :B1
          :value: zxcv

类树


TL；DR：对于您的用例来说，这看起来非常可靠。
那么
parent.values.any呢？{| v | v==child}
？@urigassi我打赌这是最没有效率的方法。@mudasobwa-好的，那么
parent.values.any？{| v | v.equal？child}
虽然听起来有点奇怪，但在使用之前，我会先用
：parent=>…
tuplas更改
哈希值。或者，如果哈希在运行期间几乎没有更新，monkeypatch将插入元素，提供相应的
：parent=>…
添加。为了使结构保持一致，根哈希还应具有：name和：children键。