Question

我有一个SQL查询，它通过级联所有导致根节点的节点来返回从叶到节点的完整路径，例如叶'H'是：

H-G-F-E-D-C-B-A

其中A是根节点。此级联值是叶子H的ID，因为它是导致该叶子且不会重复的所有节点的组合，路径上的每个节点ID本身就是其祖先的级联：

H-G-F-E-D-C-B-A =>LEAF ID
  G-F-E-D-C-B-A
    F-E-D-C-B-A
      E-D-C-B-A
        D-C-B-A
          C-B-A
            B-A
              A => ROOT ID

问题是，我需要一种算法，该算法可以产生上面列出的所有路径，但只能从类似H-F-E-D-C-B-A的字符串开始。所有路径都可以以字符串数组形式返回，语言可以是java，python或javascript，对于当前应用程序，我更喜欢javascript，但是任何可以显示算法的语言都可以。

当前，这就是我在javascript中拥有的内容：

var text = "";
var array =[];
var i=0;
var j=0;
var pathstring = 'H-G-F-E-D-C-B-A';
var pathleaf = pathstring.split('-');
for (i=0; i< pathleaf.length; i++)
{
 for (j=0; j< pathleaf.length; j++)
 {
 if(j-1>=0)
   array.push(pathleaf[j] +"-"+ pathleaf[j-1]);
 }
 if(i-1>=0){
 text += array[i] +"-"+ array[i-1] + "<br>";
 }
}

test返回以下内容：

F-G-G-H
E-F-F-G
D-E-E-F
C-D-D-E
B-C-C-D
A-B-B-C
G-H-A-B

Answer 1

这是一种可以在Java中实现的方法，您可能可以适应Javascript。

static String[] leafIDs(String s)
{
    List<String> sa = new ArrayList<>();
    char[] ca = new char[s.length()];
    for(int j=0, i=s.length()-1; i>=0; i--,j++)
    {
        if((ca[j] = s.charAt(i)) == '-') sa.add(new String(ca, 0, j));
    }
    sa.add(new String(ca));
    return sa.toArray(new String[sa.size()]);
}

或者您可以使用StringBuilder

static String[] leafIDsSB(String s)
{
    List<String> sa = new ArrayList<>();
    StringBuilder b = new StringBuilder();
    for(int i=s.length()-1; i>=0; i--)
    {
        char c = s.charAt(i);
        if(c == '-') sa.add(b.toString());
        b.append(c);
    }
    sa.add(b.toString());
    return sa.toArray(new String[sa.size()]);
}

测试

public static void main(String[] args)
{
    for(String so : leafIDs("H-G-F-E-D-C-B-A")) System.out.println(so); 
}

输出：

A
A-B
A-B-C
A-B-C-D
A-B-C-D-E
A-B-C-D-E-F
A-B-C-D-E-F-G
A-B-C-D-E-F-G-H

Answer 2

在使用了不同的方法后，我提出了解决方案：

<!DOCTYPE html>
<html>
<body>

<h2>PATH STRUCTURE</h2>

<p id="demo"></p>

<script>
var text = "";
var i=0;
var j=0;
var pathstring = 'H-G-F-E-D-C-B-A';
var pathleaf = pathstring.split('-');
pathleaf.reverse();
for (i=0; i< pathleaf.length; i++)
{
    for (j=0; j< pathleaf.length; j++)
    {
        if(i-j>=0){
            text += pathleaf[i-j]+"-";
        }
        if(j===i){
            text = text.substring(0, text.length-1);
            text +="<br>"
        }
    }
}
document.getElementById("demo").innerHTML = text;
</script>
</body>
</html>

返回的文本是：

PATH STRUCTURE
A
B-A
C-B-A
D-C-B-A
E-D-C-B-A
F-E-D-C-B-A
G-F-E-D-C-B-A
H-G-F-E-D-C-B-A

现在只是问题，而不是文本将值推入数组中。

基于全路径的层次结构节点路径生成

2 个答案: