📄 segtofile(sen).c

📁 为自然语言处理领域的中文分词程序
💻 C
📖 第 1 页 / 共 5 页
字号:
		}
   }
   /*字典的内容读入链表中，先给指针赋值*/ 
   for(i=0;i<CC_NUM;i++)
   {
	   fread(&(p->m_IndexTable[i].nCount),sizeof(int),1,fp);
       if(p->m_IndexTable[i].nCount>0)
	     p->m_IndexTable[i].pWordItemHead=(PWORD_ITEM)malloc(sizeof(WORD_ITEM)*p->m_IndexTable[i].nCount);
	   else
	   {
		   p->m_IndexTable[i].pWordItemHead=NULL;
		   continue;
	   }
       j=0;
       /*字典的内容读入链表中*/ 
	   while(j<p->m_IndexTable[i].nCount)
	   {
		 fread(nBuffer,sizeof(int),3,fp);
	     p->m_IndexTable[i].pWordItemHead[j].sWord=(char *)malloc(sizeof(char)*(nBuffer[1]+1));
		 if(nBuffer[1])
		 {
			 fread(p->m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
		 }
		 p->m_IndexTable[i].pWordItemHead[j].sWord[nBuffer[1]]=0;
	     if(bReset)
		  p->m_IndexTable[i].pWordItemHead[j].nFrequency=0;
		 else
	      p->m_IndexTable[i].pWordItemHead[j].nFrequency=nBuffer[0];
		 p->m_IndexTable[i].pWordItemHead[j].nWordLen=nBuffer[1];
		 p->m_IndexTable[i].pWordItemHead[j].nHandle=nBuffer[2];
		 j+=1;
	   }
   }
   fclose(fp);
   return TRUE;
}

/**************************************************************************************
  17.到链表中查找innercode和sword, 找到的位置由nPosRet带回 
***************************************************************************************/
int FindInOriginalTable(pDictionary p,int nInnerCode,char *sWord,int nHandle,int *nPosRet)
{
    PWORD_ITEM pItems=p->m_IndexTable[nInnerCode].pWordItemHead;
	int nStart=0;
	int nEnd=p->m_IndexTable[nInnerCode].nCount-1;
	int nMid=(nStart+nEnd)/2;
	int nCmpValue;
	while(nStart<=nEnd)
	{
       nCmpValue=strcmp(pItems[nMid].sWord,sWord);
       if(nCmpValue==0&&(pItems[nMid].nHandle==nHandle||nHandle==-1))
	   {
		   if(nPosRet)
		   {
			   if(nHandle==-1)
			   {
				   nMid-=1;
				   while(nMid>=0&&strcmp(pItems[nMid].sWord,sWord)==0)

					   nMid--;
		   if(nMid<0||strcmp(pItems[nMid].sWord,sWord)!=0)
					   nMid++;
			   }
			   *nPosRet=nMid;
	       return TRUE;
		   }
		if(nPosRet)
				*nPosRet=nMid;
			return TRUE;
	   }
	   else if(nCmpValue<0||(nCmpValue==0&&pItems[nMid].nHandle<nHandle&&nHandle!=-1))
	   {
		   nStart=nMid+1;
	   }
	   else if(nCmpValue>0||(nCmpValue==0&&pItems[nMid].nHandle>nHandle&&nHandle!=-1))
       {
		   nEnd=nMid-1;
	   }
	   nMid=(nStart+nEnd)/2;
	}
    if(nPosRet)
	{
		*nPosRet=nMid-1;
	}
	return FALSE;
}

/**************************************************************************************
 18. 到链表中查找sWord，并对sWord预处理
***************************************************************************************/
int IsExist(pDictionary p,char *sWord,  int nHandle)
{
   char sWordFind[WORD_MAXLENGTH-2];
   int nPos;
   if(!PreProcessing(sWord, &nPos,sWordFind,FALSE))
	   return FALSE;
   return(FindInOriginalTable(p,nPos,sWordFind,nHandle,0));
}

/**************************************************************************************
  到链表中查找sWord，得到其词性
***************************************************************************************/
int GetHandle(pDictionary p,char *sWord,int *pnCount,int *pnHandle,int *pnFrequency)
{
   char sWordGet[WORD_MAXLENGTH-2]; 
   int nPos,nFoundPos,nTemp; 
   *pnCount=0; 
   if(!PreProcessing(sWord, &nPos,sWordGet,FALSE)) 
	   return FALSE;
   if(FindInOriginalTable(p,nPos,sWordGet,-1,&nFoundPos))
   { 
       pnHandle[*pnCount]=p->m_IndexTable[nPos].pWordItemHead[nFoundPos].nHandle; 
	   pnFrequency[*pnCount]=p->m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency; 
	   *pnCount+=1; 
	   nTemp=nFoundPos+1; 
	   while(nTemp<p->m_IndexTable[nPos].nCount&&strcmp(p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==0)
	   { 
		   pnHandle[*pnCount]=p->m_IndexTable[nPos].pWordItemHead[nTemp].nHandle; 
		   pnFrequency[*pnCount]=p->m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency; 
		   *pnCount+=1; 
		   nTemp+=1; 
	   }
	   return TRUE; 
   }  
   return FALSE;
}

/**************************************************************************************
 19. 到链表中查找sWord，得到sWord的多个匹配
***************************************************************************************/
int GetMaxMatch(pDictionary p,char *sWord, char *sWordRet,int *npHandleRet)
{
   char sWordGet[WORD_MAXLENGTH-2],sFirstChar[3]; 
   int nPos,nFoundPos,nTemp;
   PWORD_CHAIN pCur; 
   *npHandleRet=-1;
   if(!PreProcessing(sWord, &nPos,sWordGet,FALSE)) 
	   return FALSE;
   sWordRet[0]=0; 
   strncpy(sFirstChar,sWord,strlen(sWord)-strlen(sWordGet)); 
   sFirstChar[strlen(sWord)-strlen(sWordGet)]=0; 
   FindInOriginalTable(p,nPos,sWordGet,-1,&nFoundPos); 
   nTemp=nFoundPos; 
   if(nFoundPos==-1)
		nTemp=0; 
   while(nTemp<p->m_IndexTable[nPos].nCount
	   &&CC_Find(p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)!=p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
   { 
	 
	   nTemp+=1;	 
   }
   if(nTemp<p->m_IndexTable[nPos].nCount
	   &&CC_Find(p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
   { 
	   strcpy(sWordRet,sFirstChar); 
	   strcat(sWordRet,p->m_IndexTable[nPos].pWordItemHead[nTemp].sWord); 
	   *npHandleRet=p->m_IndexTable[nPos].pWordItemHead[nTemp].nHandle; 
	   return TRUE;
   }
   pCur=NULL;
   while(pCur!=NULL&&strcmp(pCur->data.sWord,sWordGet)<=0&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)
   { 
	   pCur=pCur->next;
   }
   if(pCur!=NULL&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)
   { 
	   strcpy(sWordRet,sFirstChar);
	   strcat(sWordRet,pCur->data.sWord); 
	   *npHandleRet=pCur->data.nHandle; 
	   return TRUE;
   }
   return FALSE;
}

/**************************************************************************************
 20. 到链表中查找sWord，得到sWord的词频
***************************************************************************************/
int GetFrequency(pDictionary p,char *sWord, int nHandle)
{
   char sWordFind[WORD_MAXLENGTH-2];
   int nPos,nIndex;
   /*去掉句子中的空格*/
   if(!PreProcessing(sWord, &nPos,sWordFind,FALSE)) 
	   return 0;
   /*在词典中查找词的词频*/
   if(FindInOriginalTable(p,nPos,sWordFind,nHandle,&nIndex))
   { 
		return p->m_IndexTable[nPos].pWordItemHead[nIndex].nFrequency; 
   }   
   return 0;
}

/**************************************************************************************
 21. 释放链表的各个指针
***************************************************************************************/
void UDictionary(pDictionary p)
{
	int i,j;
	for(i=0;i<CC_NUM;i++)
	{
		for(j=0;j<p->m_IndexTable[i].nCount;j++)
		{
			free(p->m_IndexTable[i].pWordItemHead[j].sWord);
			p->m_IndexTable[i].pWordItemHead[j].sWord=NULL;
		}
		free(p->m_IndexTable[i].pWordItemHead);
		p->m_IndexTable[i].pWordItemHead=NULL;		  
	}
}

/**************************************************************************************
  22.初始化链表中的各block头指针为NULL
***************************************************************************************/
void IDictionary(pDictionary p)
{
	int i;
	for(i=0;i<CC_NUM;i++)
	{
		p->m_IndexTable[i].pWordItemHead=NULL;		
		p->m_IndexTable[i].nCount=0;	
	}	
}

/**************************************************************************************
  23.从二元关系链表中查找二元关系key，并由pItemRet返回查找内容
***************************************************************************************/
int GetItem(pContextState p,int nKey,PMYCONTEXT *pItemRet)
{ 
	PMYCONTEXT pCur=p->m_pContext,pPrev=NULL;
	if(nKey==0&&p->m_pContext)
	{
		*pItemRet=p->m_pContext;
		return TRUE;
	}
	while(pCur!=NULL&&pCur->nKey<nKey)
	{ 
		pPrev=pCur;
		pCur=pCur->next;
	}
    if(pCur!=NULL&&pCur->nKey==nKey)
	{ 
		*pItemRet=pCur;
		return TRUE;
	}
	*pItemRet=pPrev;
	return FALSE;
}

/**************************************************************************************
  24.从文件中load到二元关系链表
***************************************************************************************/
int LoadContextState(pContextState p,char *sFilename)
{ 
	int i;
	FILE *fp;
	PMYCONTEXT pCur,pTemp,pPre=NULL;	
	if((fp=fopen(sFilename,"rb"))==NULL)
	{	
		return FALSE;
	}
	/*释放二元关系链表的指针，指向NULL，多个p->m_pContext指针和pCur->aTagFreq，每个包括pCur->aContextArray[i]和头pCur->aContextArray，*/
	if(!p->m_pContext)
	{
		pCur=p->m_pContext;	
	    while(pCur!=NULL)
		{
			pTemp=pCur->next;
			for(i=0;i<p->m_nTableLen;i++)
			{
				free(pCur->aContextArray[i]);
				pCur->aContextArray[i]=NULL;
			}
			free(pCur->aContextArray);
			pCur->aContextArray=NULL;
			free(pCur->aTagFreq);
			pCur->aTagFreq=NULL;
			free(pCur);
			pCur=pTemp;
		}
		free(pCur);
		pCur=NULL;
	}
    /*释放符号表的指针*/
	if(!p->m_pSymbolTable)
	{ 
		free(p->m_pSymbolTable);
		p->m_pSymbolTable=NULL;
	}
    /*从文件中读表长度*/
	fread(&p->m_nTableLen,sizeof(p->m_nTableLen),1,fp); 
	p->m_pSymbolTable=(int*)malloc( sizeof(int)*p->m_nTableLen);
	/*从文件中读符号表*/
	fread(p->m_pSymbolTable,sizeof(int),p->m_nTableLen,fp); 

    while(!feof(fp))
	{
		pCur=(PMYCONTEXT)malloc(sizeof(MYCONTEXT));
		pCur->next=NULL;
		pCur->aContextArray=(int**)malloc(sizeof(int *)*p->m_nTableLen);
		pCur->aTagFreq=(int*)malloc(sizeof(int)*p->m_nTableLen);
		for(i=0;i<p->m_nTableLen;i++)
		{
			pCur->aContextArray[i]=(int *)malloc( sizeof(int)*p->m_nTableLen);
		}
		/*从文件中读key*/
		if(fread(&pCur->nKey,sizeof(int),1,fp)<1)
		{ 
			for(i=0;i<p->m_nTableLen;i++)
			{
				free(pCur->aContextArray[i]);
				pCur->aContextArray[i]=NULL;
			}
			free(pCur->aContextArray);
			pCur->aContextArray=NULL;
			free(pCur->aTagFreq);
			pCur->aTagFreq=NULL;
			free(pCur);
			pCur=NULL;
			break;
		}
		/*从文件中读频率和tag频率*/
        fread(&pCur->nTotalFreq,sizeof(int),1,fp); 
		fread(pCur->aTagFreq,sizeof(int),p->m_nTableLen,fp); 
		for(i=0;i<p->m_nTableLen;i++)
		{		    
			/*从文件中读二元关系矩阵*/
			fread(pCur->aContextArray[i],sizeof(int),p->m_nTableLen,fp); 
		}
		if(pPre==NULL)
			p->m_pContext=pCur; 
		else
			pPre->next=pCur; 
		pPre=pCur;		
	}
	fclose(fp);
    return TRUE;
}

/**************************************************************************************
  25. 计算二元连接概率
***************************************************************************************/
double GetContextPossibility(pContextState p,int nKey, int nPrev, int nCur)
{
	PMYCONTEXT pCur;
	double valueTemp;
	int nPrevCurConFreq,nPrevFreq,nCurIndex,nPrevIndex;
    /*从二元关系表的符号表中二分查找nCur的索引*/
	nCurIndex=BinarySearch(nCur,p->m_pSymbolTable,p->m_nTableLen);
    /*从二元关系表的符号表中二分查找nPrev的索引*/
	nPrevIndex=BinarySearch(nPrev,p->m_pSymbolTable,p->m_nTableLen);
	/*没有找到则二元概率为0.000001*/
	if(!GetItem(p,nKey,&pCur)||nCurIndex==-1||nPrevIndex==-1||pCur->aTagFreq[nPrevIndex]==0||pCur->aContextArray[nPrevIndex][nCurIndex]==0)
		return 0.000001; 
	/*从关系矩阵中得到连接频率*/

	nPrevCurConFreq=pCur->aContextArray[nPrevIndex][nCurIndex];
	/*得到前一个词的频率*/
	nPrevFreq=pCur->aTagFreq[nPrevIndex];
	/*0.9×二元频率/前词频率＋0.1×前词频率/总词频*/

	valueTemp=0.9*(double)nPrevCurConFreq/(double)nPrevFreq+0.1*(double)nPrevFreq/(double)pCur->nTotalFreq;
	return valueTemp;
}

/**************************************************************************************
  26.从二元关系链表中查找Symbol的频率
***************************************************************************************/
int GetContextFrequency(pContextState p,int nKey, int nSymbol)
{ 
	PMYCONTEXT pFound;
	int nIndex,nFrequency=0;	
	if(!GetItem(p,nKey,&pFound)) 
	{	
		return 0;
	}
	/*从符号表查找Symbol的索引*/
	nIndex=BinarySearch(nSymbol,p->m_pSymbolTable,p->m_nTableLen);
    if(nIndex==-1) 
	{
		return 0;
	}
	/*得到索引的频率并返回*/
	nFrequency=pFound->aTagFreq[nIndex];
	return nFrequency;
}

/**************************************************************************************
  27.释放二元关系链表的指针
***************************************************************************************/
void UContextState(pContextState p)
{
	int i;
	PMYCONTEXT pTemp,pCur;
	if(p->m_pContext)
	{
		pCur=p->m_pContext;
		while(pCur!=NULL)
		{
			pTemp=pCur->next;
			for(i=0;i<p->m_nTableLen;i++)
			{
				free(pCur->aContextArray[i]);
				pCur->aContextArray[i]=NULL;
			}
			free(pCur->aContextArray);
			pCur->aContextArray=NULL;
			free(pCur->aTagFreq);
			pCur->aTagFreq=NULL;
			free(pCur);		
			pCur=pTemp;
		}
		free(pCur);
	    pCur=NULL;
		free(p->m_pContext);
		p->m_pContext=NULL;
		free(p->m_pSymbolTable);
		p->m_pSymbolTable=NULL;
	}	
}

/**************************************************************************************
  27. 初始化二元关系链表中的符号表指针为NULL
***************************************************************************************/
void IContextState(pContextState p)
{
	p->m_pSymbolTable=NULL;
	p->m_pContext=NULL;
}

/**************************************************************************************
  28.从动态数组中相应的行列查找其元素的值
***************************************************************************************/
💿 文件大小 2941 K
👤 上传用户 lqlm521
📂 所属分类其他
🏷️ 相关标签

#自然语言处理 #分 #程序
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -