实验题目：计算聚集系数和邻里重叠度

利用变成编写计算聚集系数和邻里重叠度的算法，使用大数据分析社会网络中的邻里关系

实验步骤与内容：

输入：
任意图的邻接矩阵

输出：
1）每个节点的聚集系数
聚集系数：节点A的聚集系数定义为A的任意两个朋友彼此也是朋友的概率——也就是A相邻的节点之间边的实际数/与A相邻节点对的个数之比
2）每个节点对的邻里重叠度
邻里重叠度:定义一条边的邻里重叠度为:与A,B均为邻居的节点数/与A,B中至少一个为邻居的节点数(不包含A，B)

步骤：

1、首先需要输入图的邻接矩阵的节点个数，确定邻接矩阵的大小。然后输入一个邻接矩阵。

2、遍历整个邻接矩阵，将所有节点的邻接节点个数存储在数组fri中，将邻接节点编号存储在集合friends中，方便查询各邻接节点之间是否相互邻接。

3、将friends集合传给getFriendsIsFriends(）方法，通过此方法计算某节点的两个朋友之间也是朋友的朋友对数，存储在each_fri数组中。

4、计算节点聚集系数，先计算所有与当前节点连接的节点中间可能构成的连接（求法：fri[i](fri[i]-1)/2），聚集系数=each_fri[i]/fri[i](fri[i]-1)/2
5、计算邻里重叠度,先计算A、B的共同邻接顶点数，将数据存储在x_y二维数组中。x_y为上三角矩阵。
A和B的邻里重叠度=x_y[i]/（fri[i]+fri[j]-x_y[i][j]）

结果测试：

注意：
①注意在计算聚集系数和邻里重叠度时分母为零的情况，应添加对分母值的判断。
②计算节点的朋友之间也为朋友的对数时，可用一个嵌套循环来遍历朋友集合，在图的邻接矩阵查找任意两个朋友之间是否存在边。为避免重复计算，内层循环的节点应从外层循环的下一个节点开始。

③计算邻里重叠度时同要需注意避免重复计算。

import java.util.ArrayList;
import java.util.Scanner;

public class test01 {
    public static void main(String[] args) {
        //图的输入
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入图的节点个数：");
        int n=sc.nextInt();
        String t=sc.nextLine();
        String[] strs=new String[n];
        int[][] mtr=new int[n][n];
        System.out.println("请输入图的邻接矩阵，数字之间以空格分隔");

        for(int i=0;i<n;i++){
            strs[i]=sc.nextLine();
            String[] ss=strs[i].split(" ");
            int j=0;
            for (String s:ss){
                mtr[i][j]=Integer.parseInt(s);
                j++;
            }
        }

        //计算聚集系数
        double[] Aggregation_coefficient=new double[n];
        int[] fri=new int[n];
        int[] each_fri=new int[n];
        for (int i = 0; i < n; i++) {
            ArrayList<Integer> friends=new ArrayList();
            for (int j = 0; j < n; j++) {
                if (mtr[i][j]==1){
                    fri[i]+=1;
                    friends.add(j);
                }
            }
            each_fri[i]=getFriendsIsFriends(friends,mtr);
            if (fri[i]!=0&&fri[i]!=1){
                Aggregation_coefficient[i]=(double)each_fri[i]/((double)fri[i]*(double)(fri[i]-1)/2);
            }else{
                Aggregation_coefficient[i]=0.00;
            }
        }

        for (int i = 0; i < n; i++) {
            char x='A';
            System.out.println((char)(x+i)+"的聚集系数为 "+String.format("%.2f", Aggregation_coefficient[i]));
        }

        //计算邻里重叠度

        int[][] x_y=new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    if(mtr[i][k]==1&&mtr[j][k]==1){
                        x_y[i][j]+=1;
                    }
                }
                double neighborhood_overlap=0.00;
                if((fri[i]+fri[j]-x_y[i][j])!=0){
                    neighborhood_overlap=(double)x_y[i][j]/(double)(fri[i]+fri[j]-x_y[i][j]);
                }else{
                    neighborhood_overlap=0;
                }
                char x='A';
                System.out.println((char)(x+i)+"和"+(char)(x+j)+"的邻里重叠度为 "+String.format("%.2f", neighborhood_overlap));

            }

        }




    }
    public static int getFriendsIsFriends(ArrayList<Integer> friends,int[][] mtr){

        int number=0;
        for (int i = 0; i <friends.size() ; i++) {
            for (int j = i+1; j < friends.size(); j++) {
                if (mtr[friends.get(i)][friends.get(j)]==1){
                    number++;
                }
            }
        }
        return number;
    }
}