neo4j遍历和图算法

阅读更多

这篇blog主要和大家分享一下neo4j中是如何对节点进行遍历，和其中集成的图论的一些常用算法。

遍历

http://docs.neo4j.org.cn/tutorials-java-embedded-traversal.html   这是neo4j官方的中文教程。

1. private static Traverser getFriends(Node node )
2. {
3. TraversalDescription td = Traversal.description()
4. .breadthFirst()
5. .relationships( RelTypes.KNOWS, Direction.OUTGOING )
6. .evaluator( Evaluators.excludeStartPosition() );
7. return td.traverse( node );
8. }

private static Traverser getFriends(Node node )
{
    TraversalDescription td = Traversal.description()
            .breadthFirst()
            .relationships( RelTypes.KNOWS, Direction.OUTGOING )
            .evaluator( Evaluators.excludeStartPosition() );
    return td.traverse( node );
}

TraversalDescription提供了用户遍历节点的方法，并且用户需要自己添加遍历的条件。

首先用户可以定义是使用深度优先还收广度优先 breadthFirst() 和 depthFirst()；relationships定义了遍历取得节点的关系类型，是入度Direction.INCOMING还是出度Direction.OUTGOING还是both；evaluator用来定义筛选的条件，比如去掉开始节点，结束节点，遍历深度（toDepth（3））等，具体可以参照官方的API文档。

1. int num = 0;
2. String result = neoNode.getProperty( "name" ) + "'s friends:\n";
3. Traverser friendsTraverser = getFriends( neoNode );
4. for ( Path friendPath : friendsTraverser )
5. {
6. output += "At depth " + friendPath.length() + " => "
7. + friendPath.endNode()
8. .getProperty( "name" ) + "\n";
9. numberOfFriends++;
10. }
11. output += "Number of friends found: " + numberOfFriends + "\n";

int num = 0;
String result = neoNode.getProperty( "name" ) + "'s friends:\n";
Traverser friendsTraverser = getFriends( neoNode );
for ( Path friendPath : friendsTraverser )
{
    output += "At depth " + friendPath.length() + " => "
              + friendPath.endNode()
                      .getProperty( "name" ) + "\n";
    numberOfFriends++;
}
output += "Number of friends found: " + numberOfFriends + "\n";

打印出结果

1. Thomas Anderson's friends:
2. At depth 1 => Trinity
3. At depth 1 => Morpheus
4. At depth 2 => Cypher
5. At depth 3 => Agent Smith
6. 找到朋友的数量: 4

Thomas Anderson's friends:
At depth 1 => Trinity
At depth 1 => Morpheus
At depth 2 => Cypher
At depth 3 => Agent Smith
找到朋友的数量: 4

下面介绍如何按照一个预先定义好的顺序遍历图。

创建一个数据库

1. Node A = db.createNode();
2. Node B = db.createNode();
3. Node C = db.createNode();
4. Node D = db.createNode();
5. A.createRelationshipTo( B, REL1 );
6. B.createRelationshipTo( C, REL2 );
7. C.createRelationshipTo( D, REL3 );
8. A.createRelationshipTo( C, REL2 );

Node A = db.createNode();
Node B = db.createNode();
Node C = db.createNode();
Node D = db.createNode();
A.createRelationshipTo( B, REL1 );
B.createRelationshipTo( C, REL2 );
C.createRelationshipTo( D, REL3 );
A.createRelationshipTo( C, REL2 );

现在关系（REL1-->REL2-->REL), 当遍历的时候，Evaluator能够对它进行检验，确保只有该关系顺序的路径才会被包括。

1. ArrayList<RelationshipType> orderedPathContext = new ArrayList<RelationshipType>();
2. orderedPathContext.add( REL1 );
3. orderedPathContext.add( withName( "REL2" ) );
4. orderedPathContext.add( withName( "REL3" ) );
5. TraversalDescription td = Traversal.description()
6. .evaluator( new Evaluator()
7. {
8. @Override
9. public Evaluation evaluate( final Path path )
10. {
11. if ( path.length() == 0 )
12. {
13. return Evaluation.EXCLUDE_AND_CONTINUE;
14. }
15. RelationshipType expectedType = orderedPathContext.get( path.length() - 1 );
16. boolean isExpectedType = path.lastRelationship()
17. .isType( expectedType );
18. boolean included = path.length() == orderedPathContext.size()
19. && isExpectedType;
20. boolean continued = path.length() < orderedPathContext.size()
21. && isExpectedType;
22. return Evaluation.of( included, continued );
23. }
24. } );

ArrayList<RelationshipType> orderedPathContext = new ArrayList<RelationshipType>();
orderedPathContext.add( REL1 );
orderedPathContext.add( withName( "REL2" ) );
orderedPathContext.add( withName( "REL3" ) );
TraversalDescription td = Traversal.description()
        .evaluator( new Evaluator()
        {
            @Override
            public Evaluation evaluate( final Path path )
            {
                if ( path.length() == 0 )
                {
                    return Evaluation.EXCLUDE_AND_CONTINUE;
                }
                RelationshipType expectedType = orderedPathContext.get( path.length() - 1 );
                boolean isExpectedType = path.lastRelationship()
                        .isType( expectedType );
                boolean included = path.length() == orderedPathContext.size()
                                   && isExpectedType;
                boolean continued = path.length() < orderedPathContext.size()
                                    && isExpectedType;
                return Evaluation.of( included, continued );
            }
        } );

打印出结果

1. Traverser traverser = td.traverse( A );
2. PathPrinter pathPrinter = new PathPrinter( "name" );
3. for ( Path path : traverser )
4. {
5. output += Traversal.pathToString( path, pathPrinter );
6. }

Traverser traverser = td.traverse( A );
PathPrinter pathPrinter = new PathPrinter( "name" );
for ( Path path : traverser )
{
    output += Traversal.pathToString( path, pathPrinter );
}

用户也可以通过自定义格式输出路径。

1. static class PathPrinter implements Traversal.PathDescriptor<Path>
2. {
3. private final String nodePropertyKey;
4. public PathPrinter( String nodePropertyKey )
5. {
6. this.nodePropertyKey = nodePropertyKey;
7. }
8. @Override
9. public String nodeRepresentation( Path path, Node node )
10. {
11. return "(" + node.getProperty( nodePropertyKey, "" ) + ")";
12. }
13. @Override
14. public String relationshipRepresentation( Path path, Node from,
15. Relationship relationship )
16. {
17. String prefix = "--", suffix = "--";
18. if ( from.equals( relationship.getEndNode() ) )
19. {
20. prefix = "<--";
21. }
22. else
23. {
24. suffix = "-->";
25. }
26. return prefix + "[" + relationship.getType().name() + "]" + suffix;
27. }
28. }

static class PathPrinter implements Traversal.PathDescriptor<Path>
{
    private final String nodePropertyKey;
public PathPrinter( String nodePropertyKey )
{
    this.nodePropertyKey = nodePropertyKey;
}

@Override
public String nodeRepresentation( Path path, Node node )
{
    return "(" + node.getProperty( nodePropertyKey, "" ) + ")";
}

@Override
public String relationshipRepresentation( Path path, Node from,
        Relationship relationship )
{
    String prefix = "--", suffix = "--";
    if ( from.equals( relationship.getEndNode() ) )
    {
        prefix = "&lt;--";
    }
    else
    {
        suffix = "--&gt;";
    }
    return prefix + "[" + relationship.getType().name() + "]" + suffix;
}

}

 图算法

neo4j中集成了一些常用的图算法，包括最短路径，Dijkstra，A＊算法。

最短路径

1. public Iterable<Path> findShortestPath(Node node1, Node node2) {
2. PathFinder<Path> finder = GraphAlgoFactory.shortestPath(
3. Traversal.expanderForTypes(RelTypes.KNOWS, Direction.BOTH), 10);
4. Iterable<Path> paths = finder.findAllPaths(node1, node2);
5. return paths;
6. }

public Iterable<Path> findShortestPath(Node node1, Node node2) {
    PathFinder<Path> finder = GraphAlgoFactory.shortestPath(
        Traversal.expanderForTypes(RelTypes.KNOWS, Direction.BOTH), 10);
        Iterable<Path> paths = finder.findAllPaths(node1, node2);
    return paths;
}

1. for(Path shortestPath: findShortestPath(aa, ab)) {
2. System.out.println(shortestPath.toString());
3. }

for(Path shortestPath: findShortestPath(aa, ab)) {
            System.out.println(shortestPath.toString());
}

Traversal.expanderForTypes用来定义遍历的深度和节点关系的出入度。

Dijkstra解决有向图中任意两个顶点之间的最短路径问题。

1. PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(
2. Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.BOTH ), "cost" );
3. WeightedPath path = finder.findSinglePath( nodeA, nodeB );
4. path.weight();

PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(
        Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.BOTH ), "cost" );

WeightedPath path = finder.findSinglePath( nodeA, nodeB );

path.weight();

 使用 A*算法是解决静态路网中求解最短路最有效的方法。

1. Node nodeA = createNode( "name", "A", "x", 0d, "y", 0d );
2. Node nodeB = createNode( "name", "B", "x", 7d, "y", 0d );
3. Node nodeC = createNode( "name", "C", "x", 2d, "y", 1d );
4. Relationship relAB = createRelationship( nodeA, nodeC, "length", 2d );
5. Relationship relBC = createRelationship( nodeC, nodeB, "length", 3d );
6. Relationship relAC = createRelationship( nodeA, nodeB, "length", 10d );
7. EstimateEvaluator<Double> estimateEvaluator = new EstimateEvaluator<Double>()
8. {
9. public Double getCost( final Node node, final Node goal )
10. {
11. double dx = (Double) node.getProperty( "x" ) - (Double) goal.getProperty( "x" );
12. double dy = (Double) node.getProperty( "y" ) - (Double) goal.getProperty( "y" );
13. double result = Math.sqrt( Math.pow( dx, 2 ) + Math.pow( dy, 2 ) );
14. return result;
15. }
16. };
17. PathFinder<WeightedPath> astar = GraphAlgoFactory.aStar(
18. Traversal.expanderForAllTypes(),
19. CommonEvaluators.doubleCostEvaluator( "length" ), estimateEvaluator );
20. WeightedPath path = astar.findSinglePath( nodeA, nodeB );

Node nodeA = createNode( "name", "A", "x", 0d, "y", 0d );
Node nodeB = createNode( "name", "B", "x", 7d, "y", 0d );
Node nodeC = createNode( "name", "C", "x", 2d, "y", 1d );
Relationship relAB = createRelationship( nodeA, nodeC, "length", 2d );
Relationship relBC = createRelationship( nodeC, nodeB, "length", 3d );
Relationship relAC = createRelationship( nodeA, nodeB, "length", 10d );

EstimateEvaluator<Double> estimateEvaluator = new EstimateEvaluator<Double>()

{

public Double getCost( final Node node, final Node goal )

{

double dx = (Double) node.getProperty( "x" ) - (Double) goal.getProperty( "x" );

double dy = (Double) node.getProperty( "y" ) - (Double) goal.getProperty( "y" );

double result = Math.sqrt( Math.pow( dx, 2 ) + Math.pow( dy, 2 ) );

return result;

}

};

PathFinder<WeightedPath> astar = GraphAlgoFactory.aStar(

Traversal.expanderForAllTypes(),

CommonEvaluators.doubleCostEvaluator( "length" ), estimateEvaluator );

WeightedPath path = astar.findSinglePath( nodeA, nodeB );