PageRank算法java实现版本

PageRank算法是Google的核心搜索算法，在所有链接型文档搜索中有极大用处，而且在我们的各种关联系统中都有好的用法，比如专家评分系统，微博搜索/排名,SNS系统等。 
   PageRank算法的依据或思想： 
    1，被重要的网页链接的越多（外链）  ，此网页就越重要 
    2，此网页对外的链接越少越重要 
    这两个依据不能是独立的，是需要一起考虑的。但是问题来了，我们怎样判断本网页的外链是很重要的呢？循环判断？那不死循环了？ 
    解决办法是：给定阀值，让循环在此临界处停止。 
   首先，我们准备了7个测试网页，这几个网页的链接情况如下:

表格的意思是 test1链接到 test2,test3 ....依次类推 ，我们大致的根据上面两个原则可以猜一下，哪个将会是排名第一的网页?哪个最不重要? 
   貌似是test4和test6? 
   下面我们看看怎样用java实现PageRank算法。 
   首先创建html实体表示类，代码如下：

Java代码  

1. /**
2. * 网页entity
3. *
4. * @author afei
5. *
6. */
7. class HtmlEntity {
8. private String path;
9. private String content;
10. /* 外链(本页面链接的其他页面) */
11. private List<String> outLinks = new ArrayList<String>();
12. /* 内链(另外页面链接本页面) */
13. private List<String> inLinks = new ArrayList<String>();
14. private double pr;
15. public String getPath() {
16. return path;
17. }
18. public void setPath(String path) {
19. this.path = path;
20. }
21. public String getContent() {
22. return content;
23. }
24. public void setContent(String content) {
25. this.content = content;
26. }
27. public double getPr() {
28. return pr;
29. }
30. public void setPr(double pr) {
31. this.pr = pr;
32. }
33. public List<String> getOutLinks() {
34. return outLinks;
35. }
36. public void setOutLinks(List<String> outLinks) {
37. this.outLinks = outLinks;
38. }
39. public List<String> getInLinks() {
40. return inLinks;
41. }
42. public void setInLinks(List<String> inLinks) {
43. this.inLinks = inLinks;
44. }
45. }

核心算法代码如下：

Java代码  

1. /**
2. * pagerank算法实现
3. *
4. * @author afei
5. *
6. */
7. public class HtmlPageRank {
8. /* 阀值 */
9. public static double MAX = 0.00000000001;
10. /* 阻尼系数 */
11. public static double alpha = 0.85;
12. public static String htmldoc = "D:\\workspace\\Test\\WebRoot\\htmldoc";
13. public static Map<String, HtmlEntity> map = new HashMap<String, HtmlEntity>();
14. public static List<HtmlEntity> list = new ArrayList<HtmlEntity>();
15. public static double[] init;
16. public static double[] pr;
17. public static void main(String[] args) throws Exception {
18. loadHtml();
19. pr = doPageRank();
20. while (!(checkMax())) {
21. System.arraycopy(pr, 0, init, 0, init.length);
22. pr = doPageRank();
23. }
24. for (int i = 0; i < pr.length; i++) {
25. HtmlEntity he=list.get(i);
26. he.setPr(pr[i]);
27. }
28. List<HtmlEntity> finalList=new ArrayList<HtmlEntity>();
29. Collections.sort(list,new Comparator(){
30. public int compare(Object o1, Object o2) {
31. HtmlEntity h1=(HtmlEntity)o1;
32. HtmlEntity h2=(HtmlEntity)o2;
33. int em=0;
34. if(h1.getPr()> h2.getPr()){
35. em=-1;
36. }else{
37. em=1;
38. }
39. return em;
40. }
41. });
42. for(HtmlEntity he:list){
43. System.out.println(he.getPath()+" : "+he.getPr());
44. }
45. }
46. /* pagerank步骤 */
47. /**
48. * 加载文件夹下的网页文件，并且初始化pr值(即init数组)，计算每个网页的外链和内链
49. */
50. public static void loadHtml() throws Exception {
51. File file = new File(htmldoc);
52. File[] htmlfiles = file.listFiles(new FileFilter() {
53. public boolean accept(File pathname) {
54. if (pathname.getPath().endsWith(".html")) {
55. return true;
56. }
57. return false;
58. }
59. });
60. init = new double[htmlfiles.length];
61. for (int i = 0; i < htmlfiles.length; i++) {
62. File f = htmlfiles[i];
63. BufferedReader br = new BufferedReader(new InputStreamReader(
64. new FileInputStream(f)));
65. String line = br.readLine();
66. StringBuffer html = new StringBuffer();
67. while (line != null) {
68. line = br.readLine();
69. html.append(line);
70. }
71. HtmlEntity he = new HtmlEntity();
72. he.setPath(f.getAbsolutePath());
73. he.setContent(html.toString());
74. Parser parser = Parser.createParser(html.toString(), "gb2312");
75. HtmlPage page = new HtmlPage(parser);
76. parser.visitAllNodesWith(page);
77. NodeList nodelist = page.getBody();
78. nodelist = nodelist.extractAllNodesThatMatch(
79. new TagNameFilter("A"), true);
80. for (int j = 0; j < nodelist.size(); j++) {
81. LinkTag outlink = (LinkTag) nodelist.elementAt(j);
82. he.getOutLinks().add(outlink.getAttribute("href"));
83. }
84. map.put(he.getPath(), he);
85. list.add(he);
86. init[i] = 0.0;
87. }
88. for (int i = 0; i < list.size(); i++) {
89. HtmlEntity he = list.get(i);
90. List<String> outlink = he.getOutLinks();
91. for (String ol : outlink) {
92. HtmlEntity he0 = map.get(ol);
93. he0.getInLinks().add(he.getPath());
94. }
95. }
96. }
97. /**
98. * 计算pagerank
99. *
100. * @param init
101. * @param alpho
102. * @return
103. */
104. private static double[] doPageRank() {
105. double[] pr = new double[init.length];
106. for (int i = 0; i < init.length; i++) {
107. double temp = 0;
108. HtmlEntity he0 = list.get(i);
109. for (int j = 0; j < init.length; j++) {
110. HtmlEntity he = list.get(j);
111. // 计算对本页面链接相关总值
112. if (i != j && he.getOutLinks().size() != 0
113. && he.getOutLinks().contains(he0.getPath())/*he0.getInLinks().contains(he.getPath())*/) {
114. temp = temp + init[j] / he.getOutLinks().size();
115. }
116. }
117. //经典的pr公式
118. pr[i] = alpha + (1 - alpha) * temp;
119. }
120. return pr;
121. }
122. /**
123. * 判断前后两次的pr数组之间的差别是否大于我们定义的阀值 假如大于，那么返回false，继续迭代计算pr
124. *
125. * @param pr
126. * @param init
127. * @param max
128. * @return
129. */
130. private static boolean checkMax() {
131. boolean flag = true;
132. for (int i = 0; i < pr.length; i++) {
133. if (Math.abs(pr[i] - init[i]) > MAX) {
134. flag = false;
135. break;
136. }
137. }
138. return flag;
139. }
140. }

直接运行算法类，得到的结果如下：

D:\workspace\Test\WebRoot\htmldoc\test4.html : 1.102472450686259 
D:\workspace\Test\WebRoot\htmldoc\test5.html : 1.068131842865856 
D:\workspace\Test\WebRoot\htmldoc\test2.html : 1.0249590169406457 
D:\workspace\Test\WebRoot\htmldoc\test3.html : 1.0046891014946187 
D:\workspace\Test\WebRoot\htmldoc\test1.html : 0.9943895104008613 
D:\workspace\Test\WebRoot\htmldoc\test7.html : 0.9051236225340915 
D:\workspace\Test\WebRoot\htmldoc\test6.html : 0.9002344550746025

此算法可以无限改造，以满足自身要求。 
另外说一句：这个table咋编辑成这幅德行了？改都改不回来。

By 阿飞哥 转载请说明