How to compare edges in a graph to implement a triadic closure like in network graphs like facebook

Question

I am trying to implement a graph that contains Vertices(nodes) that relate to a Profile class(like a Facebook profile but more mediocre). Each of the vertices(Profiles) is stored in a Binary Search Tree which is then loaded or stored in an Array-List.
Just like in a Facebook Profile some (not all since not everyone has friends) instances of the class Profile will have friends which are the edges.
Each edge relationship of the graph is stored in a text file which is then read in and added to the graph by a separate method during the graph construction.

Once this is done I am trying to implement a recommended method:
Two profiles that are not friends but will like to be friends based on the relationship possibly being a triadic closure but I have failed terribly so far and I am currently stuck.

• Currently, I was able to create a graph using a Matrix but I am stuck with trying to find a possible solution to recommend possible friends for each vertex that has a friend j who has a friend x who is not a friend of the vertex(current Profile).

• Each one of the recommended friends is supposed to be stored into an array and added to a Binary Search Tree.

  private List<Profile> getRecommendedFriends(){
          Iterator profileIterator = this.vertexProfileMap.entrySet().iterator();
          List<Profile> recommendedProfiles = new ArrayList<>();
          Boolean isContained;
  
          while(profileIterator.hasNext()){
             Map.Entry mapElement = (Map.Entry)profileIterator.next();
             Profile user = (Profile) mapElement.getValue();
             int sizeOfList =  user.numOfFriends();
  
             for(int i = 0;  i < sizeOfList; i++){
                recommendedProfiles.add(user.getFriend(i));
                for(int x = 0; x < user.numOfFriends(); x++){
                   for(int j = 0; j < user.numOfFriends(); j++){
                      isContained = user.getFriend(x).getName().equals(user.getFriend(j).getName());
                      if(!isContained){
                         recommendedProfiles.add(user.getFriend(j));
                      }
                   }
                }
             }
  
          }
          return recommendedProfiles;
  }
  

  I get a range of errors that I cannot explain:(

Answer 1

Based on the given algorithm, and assuming the Profile class will have an additional method called containsProfile(Profile p) which checks if a given profile is contained in the friend list of the user, The following brute force approach should work:

private Map<Profile,List<Profile>> getRecommendedFriends(){
    // under the asssumption that vertexProfileMap maps all Profiles/Users
    Iterator profileIterator = this.vertexProfileMap.entrySet().iterator();
    Map<Profile,List<Profile>> recommendedProfiles = new HashMap<>();
    while(profileIterator.hasNext()){
       Map.Entry mapElement = (Map.Entry)profileIterator.next();
       Profile currentUser = (Profile) mapElement.getValue();
       List<Profile> recommendedPerProfile = new ArrayList<>();
       // iterate over all of the friends of the current user
       for(int i = 0, endI = currentUser.numOfFriends(); i < endI; i++){
          Profile checkedFriend = currentUser.getFriend(i);
          // iterate over all of the friends of the currently checked friend
          for(int j = 0; endJ < checkedFriend.numOfFriends(); j < endJ; ++j) {
             Profile possibleRecommendation = checkedFriend.getFriend(j);
             // add a recommended profile if it belongs to a friend of a friend, but is not a friend of the current user
             if(!currentUser.containsProfile(possibleRecommendation)) {
                recommendedPerProfile.add(possibleRecommendation);
             }
          }
       }
       // remove possible duplicate recommendations
       recommendedProfiles = recommendedProfiles.stream()
       .distinct()
       .collect(Collectors.toList());
       // map the current user to a list of friend recommendations
       recommendedProfiles.put(currentUser, recommendedPerProfile);
    }
    return recommendedProfiles;

}