This Cypher query finds the minimum element within a provided list of numbers. It's a fundamental operation used in various data analysis tasks, such as identifying the lowest value in a dataset or finding the smallest p...

The algorithm initializes a variable `currentMin` with the first element of the input list. It then iterates through the remaining elements of the list. In each iteration, it compares the current element with `currentMin`. If the current element is found to be smaller than `currentMin`, `currentMin` is updated to this new smaller value. This process continues until all elements have been checked. The time complexity is O(n), where n is the number of elements in the list, because each element is visited exactly once. The space complexity is O(1) as it only uses a few variables to store the current minimum and loop index, regardless of the input list size. An edge case for an empty list is handled by returning `null`.

FUNCTION findMinimum(numbers): IF numbers IS empty: RETURN null END LET currentMin = numbers[0] FOR i FROM 1 TO length(numbers) - 1: LET currentElement = numbers[i] IF currentElement < currentMin: SET currentMin = curren...

This Cypher query implements a recursive Depth-First Search (DFS) algorithm to find all possible paths between a specified start node and end node in a graph. It's useful for analyzing network connectivity, exploring rel...

The algorithm uses a recursive DFS approach. The `dfsPaths` function takes the current node, target node, a list of visited nodes, and the current path as arguments. The base case is when the `currentNode` equals the `targetNode`, at which point the current path is returned. To prevent infinite loops in graphs with cycles, the algorithm maintains a `visitedNodes` list. Before exploring neighbors, the current node is added to `visitedNodes`. For each neighbor that has not been visited, the `dfsPaths` function is called recursively. The paths returned from these recursive calls are aggregated. The time complexity is roughly O(V + E) in a Directed Acyclic Graph (DAG), but can be exponential in graphs with many cycles, as it explores all possible paths. The space complexity is O(V) for the recursion stack and visited set in the worst case.

FUNCTION dfsPaths(currentNode, targetNode, visitedNodes, currentPath): IF currentNode IS targetNode: RETURN currentPath + [currentNode.id] END ADD currentNode.id TO visitedNodes LET allFoundPaths = [] FOR EACH neighbor O...

This query counts the number of nodes with the label 'Person' that also have a 'city' property matching a given value. It's a fundamental operation for understanding the distribution of entities within a graph. For examp...

The query uses a simple `MATCH` clause to find nodes with both a label ('Person') and a specific property value ('city' equal to `$cityName`). The `count(n)` aggregation then returns the total number of such nodes. This is a very efficient operation, typically O(N) in the worst case where N is the number of nodes with the 'Person' label, but often much faster if the 'city' property is indexed, approaching O(1) or O(log N) depending on index performance. Edge cases include no nodes matching the criteria (returns 0) or an empty graph.

1. Match nodes with a specific label and property value. 2. Count the matched nodes. 3. Return the count.

This query identifies all triangular cycles (cycles of length 3) in a directed graph. It's crucial for understanding local network structures, such as feedback loops in systems or cliques in social networks. For instance...

The query uses a pattern match to define a path of three relationships that returns to the starting node: `(a)-[:REL1]->(b)-[:REL2]->(c)-[:REL3]->(a)`. The `WHERE id(a) < id(b) AND id(b) < id(c)` clause is a common technique to prevent duplicate reporting of the same cycle in different orders (e.g., a->b->c->a vs. b->c->a->b). This ensures each unique triangular cycle is returned only once. The time complexity can be high, potentially O(N^3) in dense graphs, as it explores many path combinations. Space complexity is proportional to the number of cycles found. Edge cases include graphs with no cycles, or graphs with nodes that have self-loops (which this query correctly excludes by requiring distinct nodes `a`, `b`, and `c` implicitly due to the ordering constraint).

1. Match a path starting at node 'a', going through 'b' and 'c', and returning to 'a'. 2. Ensure the relationships are directed and form a cycle. 3. Add a condition to uniquely identify each cycle (e.g., by ordering node...

This Cypher query finds all simple paths between two specified nodes, allowing for paths of variable length up to a defined maximum depth. It's useful for exploring all possible connections or routes in a network, such a...

The query first defines the `startNodeName`, `endNodeName`, and `maxDepth`. It then matches the corresponding nodes in the graph. The core of the query is the `apoc.algo.allSimplePaths` procedure, which efficiently finds all simple paths between the two nodes. The `'<' + maxDepth` parameter specifies that paths of length 1 up to `maxDepth` should be considered. The `1` as the last argument to `allSimplePaths` indicates that relationships can be traversed in either direction. The results are returned as a collection of paths. The time complexity for finding all simple paths can be exponential in the worst case, as the number of paths can grow very rapidly with graph size and density. Space complexity is proportional to the number of paths found. Edge cases include non-existent nodes (no paths returned), identical start and end nodes (potentially a path of length 0 if allowed by the procedure), and the maximum depth constraint preventing excessively long paths.

1. Define start node identifier, end node identifier, and maximum path length. 2. Match the start and end nodes in the graph. 3. Use a graph traversal algorithm (e.g., `apoc.algo.allSimplePaths`) to find all simple paths...

This query finds the shortest path between two specified nodes in a Neo4j graph. It utilizes the APOC library's `allSimplePaths` procedure to find all simple paths and then orders them by length to return the shortest on...

The `shortestPath` query leverages the `apoc.algo.allSimplePaths` procedure to explore paths in the graph. This procedure, when configured with a maximum depth, efficiently finds all simple paths between the `startNode` and `endNode`. By ordering the results by the length of the path and limiting to one, we effectively isolate the shortest path. The time complexity depends on the graph structure and the maximum path length considered, but for dense graphs or long paths, it can be exponential. Space complexity is proportional to the number of paths found. Edge cases include disconnected components (no path found) and identical start/end nodes (path of length 0).

1. Define start and end node identifiers. 2. Use `apoc.algo.allSimplePaths` to find all simple paths between start and end nodes, with a specified maximum depth. 3. Return the path with the minimum length. 4. Handle case...

This query finds all nodes that have at least one direct relationship with a specified starting node, considering both incoming and outgoing relationships. It's useful for exploring immediate neighbors in any graph, such...

The query starts by matching the `startNode`. It then uses `OPTIONAL MATCH` clauses to find nodes connected via outgoing relationships (`(startNode)-[r]->(connectedNode)`) and incoming relationships (`(connectedNode)-[r2]->(startNode)`). The `WITH` clause passes the `startNode` and `connectedNode` to the next stage. The `WHERE` clause filters out null `connectedNode`s (from the `OPTIONAL MATCH`) and ensures the `connectedNode` is not the `startNode` itself. Finally, `RETURN DISTINCT connectedNode` ensures each unique connected node is listed only once. The time complexity is roughly O(degree(startNode)), making it efficient for finding immediate neighbors. Space complexity is O(degree(startNode)). Edge cases include isolated nodes (no connections) and self-loops (handled by the `id(connectedNode) <> id(startNode)` check).

1. Match the starting node. 2. Optionally match nodes connected by outgoing relationships. 3. Optionally match nodes connected by incoming relationships. 4. Combine results and filter out the starting node itself and any...

This query identifies all nodes in the graph that do not have any outgoing relationships. This is useful for finding terminal nodes in a directed graph, such as the end points of processes, or nodes that are not initiati...

The query uses a simple `MATCH (n)` to select all nodes in the graph. The `WHERE NOT (n)-->(:Any)` clause then filters these nodes. The pattern `(n)-->(:Any)` checks if node `n` has any outgoing relationship to any other node (represented by `:Any`, which matches any label). The `NOT` negates this, so only nodes for which this pattern is false (i.e., they have no outgoing relationships) are returned. This is an efficient query, typically O(N) where N is the total number of nodes, as it only needs to check the outgoing edges for each node. If indexes are used on relationships, performance can be further improved. Edge cases include an empty graph (returns nothing) or a graph where all nodes have outgoing relationships (returns nothing).

1. Match all nodes in the graph. 2. For each node, check if it has any outgoing relationships. 3. If a node has no outgoing relationships, return it.