用Python或CQL代码实现 取出neo4j中的节点 user,productA,productB,并将数据转成用户商品矩阵，再转换成邻接表的存储

Python实现：

from neo4j import GraphDatabase

# 连接Neo4j数据库
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("username", "password"))

# 查询节点user, productA, productB
with driver.session() as session:
    result = session.run("MATCH (n:user) RETURN n")
    users = [record['n']['name'] for record in result]
    
    result = session.run("MATCH (n:productA) RETURN n")
    productsA = [record['n']['name'] for record in result]
    
    result = session.run("MATCH (n:productB) RETURN n")
    productsB = [record['n']['name'] for record in result]

# 构造用户商品矩阵
matrix = []
with driver.session() as session:
    for user in users:
        row = []
        for productA in productsA:
            result = session.run("MATCH (n:user {name: $user})-[r:BUY]->(p:productA {name: $productA}) RETURN r", user=user, productA=productA)
            if result.single() is None:
                row.append(0)
            else:
                row.append(1)
        for productB in productsB:
            result = session.run("MATCH (n:user {name: $user})-[r:BUY]->(p:productB {name: $productB}) RETURN r", user=user, productB=productB)
            if result.single() is None:
                row.append(0)
            else:
                row.append(1)
        matrix.append(row)

# 构造邻接表
adjacency_list = {}
for i in range(len(users)):
    user = users[i]
    adjacency_list[user] = []
    for j in range(len(productsA) + len(productsB)):
        product = productsA[j] if j < len(productsA) else productsB[j - len(productsA)]
        if matrix[i][j] == 1:
            adjacency_list[user].append(product)

CQL实现：

// 查询节点user, productA, productB
MATCH (n:user) RETURN n.name AS user
MATCH (n:productA) RETURN n.name AS productA
MATCH (n:productB) RETURN n.name AS productB

// 构造用户商品矩阵
WITH collect(DISTINCT user) AS users, collect(DISTINCT productA) AS productsA, collect(DISTINCT productB) AS productsB
UNWIND users AS user
WITH user, productsA, productsB
UNWIND productsA AS productA
OPTIONAL MATCH (u:user {name: user})-[r:BUY]->(p:productA {name: productA})
WITH user, productsA, productsB, collect(CASE WHEN r IS NULL THEN 0 ELSE 1 END) AS rowA
UNWIND productsB AS productB
OPTIONAL MATCH (u:user {name: user})-[r:BUY]->(p:productB {name: productB})
WITH user, productsA, productsB, rowA, collect(CASE WHEN r IS NULL THEN 0 ELSE 1 END) AS rowB
WITH rowA + rowB AS row, user
WITH [x IN row | toInteger(x)] AS row, user
WITH row, user, [i IN range(0, size(row)-1) | productsA[i] + productsB[i]] AS products
WITH row, user, reduce(s = [], i IN range(0, size(row)-1) | s + CASE WHEN row[i] = 1 THEN [products[i]] ELSE [] END) AS items
WITH user, items

// 构造邻接表
WITH collect(user) AS users, collect(items) AS items
UNWIND users AS user
WITH user, items
UNWIND items AS item
WITH user, collect(item) AS items
RETURN user, items

以上两段代码分别连接Neo4j数据库，查询节点user、productA、productB，然后根据这些节点构造用户商品矩阵，最后根据用户商品矩阵构造邻接表。其中Python代码使用了Neo4j的Python驱动程序，CQL代码使用了Neo4j的Cypher查询语言。