数据库与索引结构

最新推荐文章于 2023-05-24 08:00:00 发布
最新推荐文章于 2023-05-24 08:00:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： Search Engine 文章标签： 数据库 string exception null dictionary insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoxu1987728/article/details/2673492
版权

由文章标题可知  我们要建立数据库和索引。

一，定义Product类    
此类相当于MVC中的容器装载了数据库和索引所需要的对象，例如：category、name、type、content、summary、imageURI、originalRrl、updatedtime。顺序没关系，代码如下：

package com.luceneheritrixbook.core;

public class Product {
	private String category=null;
	private String name=null;
	private String type=null;
	private String content=null;
	private String summary=null;
	private String imageURI=null;
	private String updatedtime=null;
	private String originalUrl=null;
	public String getCategory() {
		return category;
	}
	public void setCategory(String category) {
		this.category = category;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public String getImageURI() {
		return imageURI;
	}
	public void setImageURI(String imageURI) {
		this.imageURI = imageURI;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getOriginalUrl() {
		return originalUrl;
	}
	public void setOriginalUrl(String originalUrl) {
		this.originalUrl = originalUrl;
	}
	public String getSummary() {
		return summary;
	}
	public void setSummary(String summary) {
		this.summary = summary;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getUpdatetime() {
		return updatedtime;
	}
	public void setUpdatetime(String updatetime) {
		this.updatedtime = updatetime;
	}

}

二：定义Lucene的Document格式（即用于搜索的field域）

package com.luceneheritrixbook.index;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;

import com.luceneheritrixbook.core.Product;

public class ProductDocument {
	private static final String PRODUCT_ID="productid";
	private static final String INDEX_TIME="indextime";
	private static final String PRODUCT_URL="productrul";
	private static final String CATEGORY="category";
	private static final String PRODUCT_NAME="name";
	private static final String PRODUCT_TYPE="type";
	
	public static Document buildProductDocument(Product product,int id)
	{
		Document doc=new Document();
		
		Field identifier=new Field(PRODUCT_ID,id+"",Field.Store.YES,
				Field.Index.UN_TOKENIZED);
		
		long mills=System.currentTimeMillis();
		Field indextime=new Field(INDEX_TIME,mills+"",Field.Store.YES,
				Field.Index.UN_TOKENIZED);
		
		Field producturl=new Field(PRODUCT_URL,product.getOriginalUrl(),Field.Store.YES,
				Field.Index.UN_TOKENIZED);
		
		Field category=new Field(CATEGORY,product.getCategory(),Field.Store.YES,
				Field.Index.TOKENIZED);
		
		Field name=new Field(PRODUCT_NAME,product.getName(),Field.Store.YES,
				Field.Index.TOKENIZED);
		
		Field type=new Field(PRODUCT_TYPE,product.getType(),Field.Store.YES,
				Field.Index.TOKENIZED);
		
		String text=product.getCategory();
		text+=" "+product.getName();
		text+=" "+product.getType();
		Field all=new Field(PRODUCT_ID,text,Field.Store.YES,
				Field.Index.TOKENIZED);
		
		doc.add(identifier);
		doc.add(indextime);
		doc.add(producturl);
		doc.add(category);
		doc.add(name);
		doc.add(type);
		doc.add(all);
		
		return doc;
	}

}

 

三、对数据库进行操作（即向数据库中插入获得的product对象）

package com.luceneheritrixbook.database;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

import com.luceneheritrixbook.core.Product;

public class ProductJDBC {
	private Connection con = null;

	private Statement stmt = null;

	private ResultSet rs = null;

	private PreparedStatement pstmt = null;

	private boolean autoCommit = true;

	public ProductJDBC(String url, String usr, String pwd) throws Exception 
	{
		Class.forName("com.mysql.jdbc.Driver").newInstance();
		con = DriverManager.getConnection(url, usr, pwd);
		
		con.setAutoCommit(autoCommit);
	}

	public int addProduct(Product p) throws Exception 
	{

		int nextid = getNextId();

		if (nextid < 0) {
			throw new Exception("Can&apos;t get next id.");
		}
		
		String content=p.getContent();
		String summary=p.getSummary();
		String imageURI=p.getImageURI();
		String originalUrl=p.getOriginalUrl();
		String category=p.getCategory();
		String name=p.getName();
		String type=p.getType();
		String updatetime=p.getUpdatetime();
		
		String expr="insert into product(content,abstractcontent,url," +
				"imageurl,category,name,type,updatedtime)values(?,?,?,?,?,?,?,?)";
		
		pstmt=con.prepareStatement(expr);
		
		pstmt.setString(1, content);
		pstmt.setString(2, summary);
		pstmt.setString(3, originalUrl);
		pstmt.setString(4, imageURI);
		pstmt.setString(5, category);
		pstmt.setString(6, name);
		pstmt.setString(7, type);
		pstmt.setString(8, updatetime);
		
		pstmt.execute();
		
		return nextid;
	}
	
	private int getNextId() throws Exception {

		int result = -1;

		String sql = "select max(id)+1 from product";

		stmt = con.createStatement();
		rs = stmt.executeQuery(sql);

		while (rs.next()) {
			result = rs.getInt(1);
		}

		return result;
	}
	
	public void close()
	{
		if(con!=null)
		{
			try
			{
				con.close();
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
			finally
			{
				con=null;
			}
		}
	}
}
/*
 * 在这里我发现了一个不好的地方，那就是完全相同的两个产品信息可以同时存入数据库
 * */

四、对索引进行操作（其实就是把前面所构建的词库加入JE分词，然后连同Document一起加入索引器）

package com.luceneheritrixbook.index;

import java.io.FileReader;

import jeasy.analysis.MMAnalyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.index.IndexWriter;

import com.luceneheritrixbook.core.Product;
import com.luceneheritrixbook.searchengine.config.PropertyConfiguration;

public class ProductIndexer
{
     private String indexPath="";
     private IndexWriter writer=null;
     private Analyzer analyzer=null;
     private String dictionary_file=PropertyConfiguration.getWordDictionary();
     
     public ProductIndexer(String indexPath)throws Exception
     {
    	 this.indexPath=indexPath;
    	 initialize();
     }
     
     private void initialize() throws Exception
     {
    	 analyzer=new MMAnalyzer();
    	 FileReader reader=new FileReader(dictionary_file);
    	 ((MMAnalyzer)analyzer).addDictionary(reader);
    	 writer=new IndexWriter(indexPath,analyzer,true);
     }
     
     public void close()
     {
    	 try
    	 {
    		 writer.close();
    	 }
    	 catch(Exception e)
    	 {
    		 e.printStackTrace();
    		 writer=null;
    	 }
     }
     
     public void addProduct(Product product,int id)throws Exception
     {
    	 writer.addDocument(ProductDocument.buildProductDocument(product,id));
     }
     
     //优化索引
     public void optimizeIndex()throws Exception
     {
    	 writer.optimize();
     }
}

五、调用数据库处理类和索引处理类（这是建立数据库和索引最主要的类，主要过程是这样的：首先初始化数据库和索引的实例，然后是从ｈｅｒｉｔｉｘ中读取的镜像网页，通过Ｆｉｌｅ的循环遍历从中读取每一个ｐｒｏｄｕｃｔ的详细信息，然后生成一个Ｐｒｏｄｕｃｔ对象，这样通过参数ｐｒｏｄｕｃｔ就可以把数据存入数据库和索引了）代码如下：

package com.luceneheritrixbook.core;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

import com.luceneheritrixbook.database.ProductJDBC;
import com.luceneheritrixbook.extractor.Extractor;
import com.luceneheritrixbook.index.ProductIndexer;
import com.luceneheritrixbook.searchengine.config.PropertyConfiguration;

public class ProductTextFileProcessor
{
	/**
	 * @param args
	 */
	private String[] directionaries;
	
	private static final String dbUrl=PropertyConfiguration.getDBUrl();
	private static final String dbUsr=PropertyConfiguration.getDBUsr();
	private static final String dbPwd=PropertyConfiguration.getDBPwd();
	private static final String indexPath=PropertyConfiguration.getIndexStorePath();
	
	private ProductJDBC productJDBC=null;
	private ProductIndexer indexer=null;
	
	public final static int SUMMARY_LENGTH=80;//内容简介的最大数量
	
	public ProductTextFileProcessor()
	{
		initialize();
	}
	
	public void initialize()
	{
		try
		{
			productJDBC=new ProductJDBC(dbUrl,dbUsr,dbPwd);
			indexer=new ProductIndexer(indexPath);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}	
	}
	
	public void setDirectionaries(String[] directionaries)
	{
		this.directionaries=directionaries;
	}
	
	protected void process()throws Exception
	{
		if(productJDBC==null)
		{
			throw new Exception("Database connection failed,pls retry");
		}
		
		if(indexer==null)
		{
			throw new Exception("Lucene index failed,pls retry");
		}
		
		if(directionaries==null||directionaries.length==0)
		{
			System.out.print("失败了");
			return;
		}
		
		try
		{
			for(int i=0;iSUMMARY_LENGTH)
			{
				p.setSummary(contentstr.substring(0,SUMMARY_LENGTH-1));
			}
			else
				p.setSummary(contentstr);

			p.setUpdatetime(updatetime);
			//以上一个product对象已存在
			//先存入数据库，然后h获得返回的id值；
			int nextid=insert2DB(p);//这里出现了错误,其实还是ProductJDBC.java里面出现了错误
			
			//用刚返回的id值，向索引中加入Product对象
			buildIndex(p,nextid);	
		}
		//索引优化
		 optimizeindex();
		 /*这只是一个函数，不能直接用来优化索引，不知道为什么
		  * 不直接用indexer.optimizeIndex();
		  */
	}
	
	protected int insert2DB(Product p)throws Exception
	{
		return productJDBC.addProduct(p);
	}
	
	protected void buildIndex(Product p,int nextid)throws Exception
	{
		indexer.addProduct(p,nextid);
	}
	//优化所以你
	private void optimizeindex()throws Exception
	{
		indexer.optimizeIndex();
	}
	
	private void closeIndex()throws Exception
	{
		indexer.close();
	}
	
	private void closeDB()
	{
		productJDBC.close();
	}
	
 /*	public String getDbPwd()
	{
		return dbPwd;
	}
	
	public String getDbUrl()
	{
		return dbUrl;
	}
	
	public String getDbUsr()
	{
		return dbUsr;
	}
	
	public String getIndexPath()
	{
		return indexPath;
	}*/
	//上述方法书上有，但我看来看去，发现它好像也没什么用，就暂时给冻结了，好像也没报错。
	
	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub
		ProductTextFileProcessor pro=new ProductTextFileProcessor();
		pro.initialize();//前面已经有了，不知道是不是多此一举。
		
		String path1="c://product//mobile//";
		pro.setDirectionaries(new String[]{path1});//这句到底是什么意思
        
		pro.process();
	}
}

数据库还好说，以后肯定要用到，可是这个索引到底有什么用啊，好像后面没用到，不过我猜肯定是我弄</STRONG>错了，怎么可能会用不到，开玩笑嘛，等着看吧  ……

注：先第五发现有错误，修改如下：

  1. package com.luceneheritrixbook.core;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileReader;
  7. import com.luceneheritrixbook.database.ProductJDBC;
  8. import com.luceneheritrixbook.extractor.Extractor;
  9. import com.luceneheritrixbook.index.ProductIndexer;
  10. import com.luceneheritrixbook.searchengine.config.PropertyConfiguration;
  12. public class ProductTextFileProcessor
  13. {
  14.     /**
  15.      * @param args
  16.      */
  17.     private String[] directionaries;
  18.     
  19.     private static final String dbUrl=PropertyConfiguration.getDBUrl();
  20.     private static final String dbUsr=PropertyConfiguration.getDBUsr();
  21.     private static final String dbPwd=PropertyConfiguration.getDBPwd();
  22.     private static final String indexPath=PropertyConfiguration.getIndexStorePath();
  23.     
  24.     private ProductJDBC productJDBC=null;
  25.     private ProductIndexer indexer=null;
  26.     
  27.     public final static int SUMMARY_LENGTH=80;//到底有什么用呢
  28.     
  29.     public ProductTextFileProcessor()
  30.     {
  31.         initialize();
  32.     }
  33.     
  34.     public void initialize()
  35.     {
  36.         try
  37.         {
  38.             productJDBC=new ProductJDBC(dbUrl,dbUsr,dbPwd);
  39.             indexer=new ProductIndexer(indexPath);
  40.         }
  41.         catch(Exception e)
  42.         {
  43.             e.printStackTrace();
  44.         }   
  45.     }
  46.     
  47.     public void setDirectionaries(String[] directionaries)
  48.     {
  49.         this.directionaries=directionaries;
  50.     }
  51.     
  52.     protected void process()throws Exception
  53.     {
  54.         if(productJDBC==null)
  55.         {
  56.             throw new Exception("Database connection failed,pls retry");
  57.         }
  58.         
  59.         if(indexer==null)
  60.         {
  61.             throw new Exception("Lucene index failed,pls retry");
  62.         }
  63.         
  64.         if(directionaries==null||directionaries.length==0)
  65.         {
  66.             System.out.print("失败了");
  67.             return;
  68.         }
  69.         
  70.         try
  71.         {
  72.             for(int i=0;i<directionaries.length;i++)
  73.             {
  74.                 File f=new File(directionaries[i]);
  75.                 traverse(f);
  76.             }
  77.             //处理完成后关闭数据库
  78.             closeDB();
  79.             
  80.             //处理完成后关闭索引器
  81.             closeIndex();
  82.         }
  83.         catch(Exception e)
  84.         {
  85.             e.printStackTrace();
  86.         }
  87.     }
  88.     
  89.     protected void traverse(File file)throws Exception
  90.     {
  91.         String[] files=file.list();
  92.         for(int i=0;i<files.length;i++)
  93.         {
  94.             File productfile=new File(file,files[i]);
  95.             
  96.             String fname=productfile.getName();
  97.             System.out.println(fname);
  98.             
  99.             BufferedReader reader=new BufferedReader(new FileReader(productfile));
  100.             
  101.             String url=reader.readLine();
  102.             String name=reader.readLine();
  103.             String type=reader.readLine();
  104.             String imageURI="";
  105.             String updatetime=fname.substring(fname.lastIndexOf("-")+1,fname.lastIndexOf("."));
  106.             
  107.             StringBuffer content=new StringBuffer();
  108.             String line=reader.readLine();
  109.             while(line!=null&&!line.equals(Extractor.SEPARATOR))//&&!line.equals(Extractor.SEPARATOR) 难道调用了前面的东西
  110.             {
  111.                 content.append(line).append("/r/n");
  112.                 line=reader.readLine();
  113.             }
  114.             
  115.             imageURI=reader.readLine();
  116.             
  117.             //生成并设置"一个"product对象
  118.             Product p=new Product();
  119.             p.setCategory("手机");
  120.             p.setName(name);
  121.             p.setType(type);
  122.             p.setImageURI(imageURI);
  123.             //p.setContent(content);//为什么会出错呢？
  124.             p.setOriginalUrl(url);
  125.             
  126.             String contentstr=content.toString();
  127.             p.setContent(contentstr);
  128.             
  129.             if(contentstr.length()>SUMMARY_LENGTH)
  130.             {
  131.                 p.setSummary(contentstr.substring(0,SUMMARY_LENGTH-1));
  132.             }
  133.             else
  134.                 p.setSummary(contentstr);
  136.             p.setUpdatetime(updatetime);
  137.             //以上一个product对象已存在
  138.             //先存入数据库，然后h获得返回的id值；
  139.             int nextid=insert2DB(p);//这里出现了错误,其实还是ProductJDBC.java里面出现了错误
  140.             
  141.             //用刚返回的id值，向索引中加入Product对象
  142.             buildIndex(p,nextid);   
  143.         }
  144.         //索引优化
  145.          optimizeindex();
  146.          /*这只是一个函数，不能直接用来优化索引，不知道为什么
  147.           * 不直接用indexer.optimizeIndex();
  148.           */
  149.     }
  150.     
  151.     protected int insert2DB(Product p)throws Exception
  152.     {
  153.         return productJDBC.addProduct(p);
  154.     }
  155.     
  156.     protected void buildIndex(Product p,int nextid)throws Exception
  157.     {
  158.         indexer.addProduct(p,nextid);
  159.     }
  160.     //优化所以你
  161.     private void optimizeindex()throws Exception
  162.     {
  163.         indexer.optimizeIndex();
  164.     }
  165.     
  166.     private void closeIndex()throws Exception
  167.     {
  168.         indexer.close();
  169.     }
  170.     
  171.     private void closeDB()
  172.     {
  173.         productJDBC.close();
  174.     }
  175.     
  176.  /* public String getDbPwd()
  177.     {
  178.         return dbPwd;
  179.     }
  180.     
  181.     public String getDbUrl()
  182.     {
  183.         return dbUrl;
  184.     }
  185.     
  186.     public String getDbUsr()
  187.     {
  188.         return dbUsr;
  189.     }
  190.     
  191.     public String getIndexPath()
  192.     {
  193.         return indexPath;
  194.     }*/
  195.     //上述方法书上有，但我看来看去，发现它好像也没什么用，就暂时给冻结了，好像也没报错。
  196.     
  197.     public static void main(String[] args) throws Exception
  198.     {
  199.         // TODO Auto-generated method stub
  200.         ProductTextFileProcessor pro=new ProductTextFileProcessor();
  201.         pro.initialize();//前面已经有了，不知道是不是多此一举。
  202.         
  203.         String path1="c://product//mobile//";
  204.         pro.setDirectionaries(new String[]{path1});//这句到底是什么意思
  205.         
  206.         pro.process();
  207.     }
  208. }
caoxu1987728
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之六度空间
weixin_33725807的博客
11-30 3285
实验题目: “六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。” 也就是在无向图中，以节点作为人，两个节点之间的路径小于等于6。 实验要求求出与一个节点满足上述要求的其他...
数据库索引的结构
zhoxing
03-03 1170
常见的数据库索引的结构有以下几种： 1 B+树索引     B+树是应文件系统所需而出的一种B树的变型树。一棵m阶的B+树和m阶的B-树的差异在于： 1.有n棵子树的结点中含有n个关键字，每个关键字不保存数据，只用来索引，所有数据都保存在叶子节点。 2.所有的叶子结点中包含了全部关键字的信息，及指向含这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大顺序链接。 3.所有的非终
数据结构学习记录——图应用实例-六度空间（题目描述、算法思路、伪代码及解读、图解）
li13437542099的博客
05-24 1065
换句话说，你通过你认识的某个人，再通过他们认识的另一个人，以此类推，最终可以与世界上任何一个陌生人建立联系。然后开始新一轮的循环，直到来到节点7，节点7的最后一个邻接点赋给tail，即节点19；此时last指向节点7；现假设给定了一个社交网络图，请对每个节点计算符合“六度空间”理论的节点占节点总数的百分比。增加计数器 count，表示访问的节点数量，并更新最后一个节点的位置为 W。然后开始遍历节点 V 的每个邻接点 W，即与节点 V 相连的节点。将起始节点 V 入队，Q为队列，用于存储待访问的节点。
《数据结构》-图的六度空间理论(二)
tyustli
08-01 1015
六度空间理论 六度空间 理论又被称作六度分隔(six degree of separation) 理论。这个理论可以通俗的阐述为：你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过六个人你就能够认识任何一个陌生人。又被称作小世界理论 在程序上，把六度空间理论中的人际关系网络抽象成一个无向图G。用图G中的一个顶点表示一个人，两个人认识与否代表这两个人的顶点之间是否有一条边来表示。从任一顶点出发用广度优先方法对图进行遍历，统计所有路径长度不超过7的顶点。 ...
数据结构算法——1091. 六度空间
JamSlade的博客
12-22 1117
题目 输入 10 9 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 输出 1: 70.00% 2: 80.00% 3: 90.00% 4: 100.00% 5: 100.00% 6: 100.00% 7: 100.00% 8: 90.00% 9: 80.00% 10: 70.00% 思路 BFS应该没啥大问题，利用queue存放pair<int,int>就可以 注意使用BFS时候的mark数组记录是否便利某一个点的问题 代码 #include<iostream
数据结构-2020夏 06-图3 六度空间 (30分)
Encore47的博客
08-13 421
原题地址 解题思路 方法一 用装模做样的伪代码写的邻接表（有一部分还是没顶住，用了现成的）写的BFS做法，但是是用存储头结点的数组来存端点对应的层数。也就是说只有这么一个数组来存结果，下标对应的是端点序号，数组元素的值变了就是变了。 这里就碰到了一个大坑！！遍历当前层的下一层时层数layer要+1，但是注意，做这一步之前一定要先判断端点是否访问过，不然就是WA... 需要这样做的原因主要是和我存层数的方式有关。 假设我没有经过判断，每一次层数都直接+1，那么设想下面的一种情况： 现在有两个点a
数据库之索引的数据结构
ying_coder的博客
05-26 3762
索引的数据结构主要有以下几种： （1）生成索引，建立二叉查找树/二叉排序树/二叉搜索树进行二分查找； （2）平衡二叉树，红黑树； （3）生成索引，建立B-Tree(B树/B-树)结构进行查找； （4）生成索引，建立B±Tree（B+树）结构进行查找； （5）生成索引，建立Hash结构进行查找； （6）生成索引，建立位图结构进行查找。 1、 二叉查找树 二叉查找树的特点： （1）二叉查找树的每一个节点的值都大于其左子树上所有节点的值，且小于其右子树上所有节点的值； （2）二叉查找树的每一个节点的左、右子树也
02.数据结构与数据库索引.md
最新发布
06-24
# 数据结构与数据库索引 > 关键词：链表、数组、散列表、红黑树、B+ 树、LSM 树、跳表 ## 引言 **数据库**是“按照 **数据结构** 来组织、存储和管理数据的仓库”。是一个长期存储在计算机内的、有组织的、可共享...
数据库索引设计与优化
04-22
数据库索引是一种数据结构，它提供了对表中数据的快速访问路径。常见的索引类型有B树（B-Tree）、哈希索引（Hash Index）和位图索引（Bitmap Index）。B树索引适用于范围查询和排序操作，哈希索引适用于等值查询，...
数据库索引设计和优化
06-24
数据库索引设计与优化是数据库管理系统中至关重要的一个环节，它直接影响到数据查询的效率、存储空间的使用以及系统的整体性能。在这个主题中，我们将深入探讨数据库索引的基础概念、设计原则、优化策略以及实际应用...
数据结构课程设计（四个实验）
05-18
该文件包含了数据结构课程实验中的四个小实验，里面的源代码均在vc6.0下调试通过……欢迎下载！
05-图3. 六度空间 (30).zip
06-23
http://blog.csdn.net/xkzju2010/article/details/46503251
数据库索引的数据结构
08-17
数据库索引的数据结构。
06-图3 六度空间
Inaho
09-27 964
有借鉴http://blog.csdn.net/xkzju2010/article/details/46503251#include #include #define MaxVertexNum 10000 int *Visited; typedef struct QNode{ int Data[MaxVertexNum]; int rear; int front; } QNode,
PTA 数据结构与算法 7-7 六度空间
番大白菜
05-22 4664
如有不对，不吝赐教 进入正题： 六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图1所示。 图1 六度空间示意图 “六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学...
数据结构——六度空间理论验证
m0_54078781的博客
06-17 4940
VS数据结构实现编程
PTA_数据结构与算法_7-7 六度空间 (30分)
hqy的草稿本
03-04 1042
“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图1所示。 图1 六度空间示意图 “六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史...
HtmlParser实例解析
lycos的六度空间
09-19 3037
 HtmlParser实例解析：网页内容：教材征订及教师用书登记通知阅读量：1111 发布时间：2006-5-12 21:24:36 实现代码如下：import java.io.BufferedWriter;import java.io.File;import java.io.FileWriter;import org.htmlparser.Node;i
数据库索引结构解析
通过理解这些索引结构及其工作原理，数据库管理员和开发人员可以更有效地设计和优化数据库，以支持高效的数据访问和查询操作。在实际应用中，选择合适的索引类型取决于数据的特性和查询模式，以达到最佳的性能平衡。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值