Princípio do PageRank e implementação da linguagem C

PageRank é um algoritmo de classificação do mecanismo de pesquisa desenvolvido pelo cofundador do Google, Larry Page. O algoritmo visualiza a Internet como um gráfico direcionado, onde as páginas da Web são representadas como nós e os links (hiperlinks) são representados como arestas.

O princípio básico do PageRank é dar a cada página um "peso", que depende da avaliação abrangente do número e da qualidade da página conectada por outras páginas. Especificamente, quando houver muitas páginas apontando para a mesma página, essa página será considerada mais importante (mais popular) e, portanto, terá maior peso.

Ao calcular o valor do PageRank, cada página receberá um valor inicial (geralmente 1). Em seguida, o valor do PageRank de cada página é calculado várias vezes usando um algoritmo iterativo até a convergência.

Durante o cálculo, o valor do PageRank de cada nó será coletado de todos os nós de entrada associados a ele (ou seja, nós apontando para este nó) e os valores do PageRank desses nós de entrada serão divididos de acordo com a proporção igual de suas arestas adjacentes Cálculo. Em última análise, o valor do PageRank é considerado como o peso relativo de cada nó para as classificações do mecanismo de pesquisa.

Resumindo, o algoritmo PageRank determina principalmente a importância relativa da página avaliando a quantidade e a qualidade dos links de entrada da página da web e para quais páginas esses links apontam e executa a classificação do mecanismo de pesquisa de acordo.

A implementação de sua fórmula é a seguinte:

$Fou$ $t=0:$
$$relações\; públicas\left(p_{};t\right)=\frac{}{N}$$
$Fou$ $t>0:$

$$relações\; públicas\left(p_{};t\right)=\frac{1-}{N}+d\times \left(\left(\underset{p_{}\in M\left(p_{}\right)}{}\frac{relações\; públicas(p_{};t-1}{D\left(p_{}\right)}\right)+\left(\underset{p_{}\in S}{}\frac{relações\; públicas(p_{};t-1}{N}\right)\right)$$

A implementação em linguagem C do algoritmo é a seguinte:

• Definição da estrutura:

//边表结点
typedef struct ArcNode{
    
    
	int adjvex;		//某条边指向的那个顶点的位置
	ArcNode * next;	//指向下一条弧的指针 
	weight w;		//权值
}ArcNode; 
//顶点表结点
typedef struct VNode{
    
    
	VertexType data;	//顶点信息
	double oldrank;
	double pagerank;
//	double sink_rank;
	ArcNode * first;	//指向第一条依附该顶点的弧的指针
}VNode;
typedef struct GraphRepr{
    
    
	VNode * node;		//邻接表
	int vexnum, arcnum;	//图的顶点数和弧数 
}Graph, *graph; 

• Implementação do algoritmo:

void graph_pagerank(graph g, double damping, double delta) {
    
    
	double sink_rank = 0;
    int N = graph_vertices_count(g);
    for(int i = 0; i < N; i++){
    
    
    	g->node[i].oldrank = 0;
		g->node[i].pagerank = 1.0/N;    
//		printf("%lf\n", g->node[i].pagerank);	
	}
	double temp_delta, min_delta = INF;
	for(int i = 0; i < N; i++){
    
    
		temp_delta = g->node[i].pagerank - g->node[i].oldrank > 0 ? g->node[i].pagerank - g->node[i].oldrank : g->node[i].oldrank - g->node[i].pagerank;
		if(temp_delta < min_delta) min_delta = temp_delta;
	}
	while(temp_delta > delta){
    
    
//		printf("%lf\n", temp_delta);
		for(int j = 0; j < N; j++){
    
    
			g->node[j].oldrank = g->node[j].pagerank;
//			printf("%lf ", g->node[j].pagerank);
		}
//		putchar('\n');
		sink_rank = 0;
		for(int j = 0; j < N; j++){
    
    
			if(g->node[j].first == NULL){
    
    
				sink_rank = sink_rank + (damping * (g->node[j].oldrank / (double)N));
			}
		}
		for(int j = 0; j < N; j++){
    
    
			g->node[j].pagerank = sink_rank + ((1 - damping) / (double)N);
			for(int k = 0; k < N; k++){
    
    
				ArcNode * temp = g->node[k].first;
				while(temp){
    
    
					if(temp->adjvex == j){
    
    
//						printf("%d\n", temp->adjvex);
						int num_outbound_edge = 1;
						ArcNode * temp_num = g->node[k].first;
						while(temp_num->next){
    
    
							num_outbound_edge++;
							temp_num = temp_num->next;
						}
//						printf("%d\n", num_outbound_edge);
						g->node[j].pagerank = g->node[j].pagerank + ((damping * g->node[k].oldrank) / (double)num_outbound_edge);
						break;
					}
					temp = temp->next;
				}
			}
		}
		min_delta = INF;
		for(int i = 0; i < N; i++){
    
    
			temp_delta = g->node[i].pagerank - g->node[i].oldrank > 0 ? g->node[i].pagerank - g->node[i].oldrank : g->node[i].oldrank - g->node[i].pagerank;
			if(temp_delta < min_delta) min_delta = temp_delta;
		}
	}		
		
    return;
}