开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
DynamicArray.cpp
资源名称：ICTCLASV1.2.rar　[点击查看]
上传用户：sunyong76
上传日期：2021-10-03
资源大小：2236k
文件大小：10k
源码类别：

多国语言处理

开发平台：

Java

DynamicArray.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. //ICTCLAS简介：计算所汉语词法分析系统ICTCLAS(Institute of Computing Technology, Chinese Lexical Analysis System)，
  3. //             功能有：中文分词；词性标注；未登录词识别。
  4. //             分词正确率高达97.58%(973专家评测结果)，
  5. //             未登录词识别召回率均高于90%，其中中国人名的识别召回率接近98%;
  6. //             处理速度为31.5Kbytes/s。
  7. //著作权：  Copyright?2002-2005中科院计算所 职务著作权人：张华平 刘群
  8. //遵循协议：自然语言处理开放资源许可证1.0
  9. //Email: zhanghp@software.ict.ac.cn
  10. //Homepage:www.nlp.org.cn;mtgroup.ict.ac.cn
  11. /****************************************************************************
  12.  *
  13.  * Copyright (c) 2000, 2001 
  14.  *     Machine Group
  15.  *     Software Research Lab.
  16.  *     Institute of Computing Tech.
  17.  *     Chinese Academy of Sciences
  18.  *     All rights reserved.
  19.  *
  20.  * This file is the confidential and proprietary property of 
  21.  * Institute of Computing Tech. and the posession or use of this file requires 
  22.  * a written license from the author.
  23.  *
  24.  * Abstract:
  25.  *           Dynamic array, and the array is generally great and sparse.
  26.  *           Dynamic Array Implement
  27.  * Author: Kevin Chang (zhanghp@software.ict.ac.cn)
  28.  *
  29.  * Notes:
  30.  *                
  31.  * 
  32.  ****************************************************************************/
  33. // DynamicArray.cpp: implementation of the CDynamicArray class.
  34. //
  35. //////////////////////////////////////////////////////////////////////
  36. #include "stdafx.h"
  37. #include "DynamicArray.h"
  38. #include <stdlib.h>
  39. #include <malloc.h>
  40. #include <string.h>
  41. //////////////////////////////////////////////////////////////////////
  42. // Construction/Destruction
  43. //////////////////////////////////////////////////////////////////////
  45. CDynamicArray::CDynamicArray(bool bRowFirst)
  46. {
  47.    m_pHead=NULL;
  48.    m_nRow=0;
  49.    m_nCol=0;
  50.    m_bRowFirst=bRowFirst;
  51. }
  53. CDynamicArray::~CDynamicArray()
  54. {
  55.    PARRAY_CHAIN pCur=m_pHead,pTemp;//The pointer of array chain
  56.    while(pCur!=NULL)
  57.    {
  58.    pTemp=pCur->next;
  59.        if(pCur->sWord)
  60. delete [] pCur->sWord;
  61.    free(pCur); 
  62.    pCur=pTemp;
  63.    }
  64. }
  65. /*********************************************************************
  66.  *
  67.  *  Func Name  : GetElement
  68.  *
  69.  *  Description:  Get the element value
  70.  *              
  71.  *
  72.  *  Parameters : nRow: the row number
  73.  *               nCol: the Column number
  74.  *    
  75.  *  Returns    : the element value if found,else Infinite value
  76.  *  Author     : Kevin Zhang  
  77.  *  History    : 
  78.  *              1.create 2001-11-7
  79.  *********************************************************************/
  81. ELEMENT_TYPE CDynamicArray::GetElement(int nRow, int nCol,PARRAY_CHAIN pStart,PARRAY_CHAIN *pRet)
  82. {
  83.    PARRAY_CHAIN pCur=pStart;
  84.    if(pStart==0)
  85.     pCur=m_pHead;
  86.    if(pRet!=0)
  87.    *pRet=NULL;
  88.    if(nRow>(int)m_nRow||nCol>(int)m_nCol)//Judge if the row and col is overflow
  89.    return INFINITE_VALUE;
  90.   if(m_bRowFirst)
  91.    {
  92.    while(pCur!=NULL&&(nRow!=-1&&(int)pCur->row<nRow||(nCol!=-1&&(int)pCur->row==nRow&&(int)pCur->col<nCol)))
  93.    {
  94.    if(pRet!=0)
  95.    *pRet=pCur;
  96.    pCur=pCur->next;
  97.    }
  98.    }
  99.    else
  100.    {
  101.    while(pCur!=NULL&&(nCol!=-1&&(int)pCur->col<nCol||((int)pCur->col==nCol&&nRow!=-1&&(int)pCur->row<nRow)))
  102.    {
  103.    if(pRet!=0)
  104.    *pRet=pCur;
  105.    pCur=pCur->next;
  106.    }
  107.    }
  108.    if(pCur!=NULL&&((int)pCur->row==nRow||nRow==-1)&&((int)pCur->col==nCol||nCol==-1))//Find the same position
  109.    {//Find it and return the value
  110.    if(pRet!=0)
  111.    *pRet=pCur;
  112.    return pCur->value;
  113.    }
  114. return INFINITE_VALUE;
  115. }
  116. /*********************************************************************
  117.  *
  118.  *  Func Name  : SetElement
  119.  *
  120.  *  Description:  Set the element value
  121.  *              
  122.  *
  123.  *  Parameters : nRow: the row number
  124.  *               nCol: the Column number
  125.  *               fValue: the value to be set
  126.  *  Returns    : the element value if found,else Infinite value
  127.  *  Author     : Kevin Zhang  
  128.  *  History    : 
  129.  *              1.create 2001-11-7
  130.  *********************************************************************/
  132. int CDynamicArray::SetElement(unsigned int nRow, unsigned int nCol, ELEMENT_TYPE fValue,int nPOS,char *sWord)
  133. {
  134.    PARRAY_CHAIN pCur=m_pHead,pPre=NULL,pAdd;//The pointer of array chain
  135.    if(nRow>m_nRow)//Set the array row
  136.    m_nRow=nRow;
  137.    if(nCol>m_nCol)//Set the array col
  138.    m_nCol=nCol;
  139.    if(m_bRowFirst)
  140.    {
  141.    while(pCur!=NULL&&(pCur->row<nRow||(pCur->row==nRow&&pCur->col<nCol)))
  142.    {
  143.    pPre=pCur;
  144.    pCur=pCur->next;
  145.    }
  146.    }
  147.    else
  148.    {
  149.    while(pCur!=NULL&&(pCur->col<nCol||(pCur->col==nCol&&pCur->row<nRow)))
  150.    {
  151.    pPre=pCur;
  152.    pCur=pCur->next;
  153.    }
  154.    }
  156.    if(pCur!=NULL&&pCur->row==nRow&&pCur->col==nCol)//Find the same position
  157.    {
  158.    pCur->value=fValue;//Set the value
  159.    pCur->nPOS=nPOS;//Set the possible POS
  160.    }
  161.    else
  162.    {
  163.        pAdd=(PARRAY_CHAIN)malloc(sizeof(ARRAY_CHAIN));//malloc a new node
  164.    pAdd->col=nCol;//get the value
  165.    pAdd->row=nRow;
  166.    pAdd->value=fValue;
  167.    pAdd->nPOS=nPOS;
  168.    if(sWord)//sWord is not empty
  169.    {
  170.    pAdd->nWordLen=strlen(sWord);
  171.    pAdd->sWord=new char[pAdd->nWordLen+1];    
  172.    strcpy(pAdd->sWord,sWord);
  173.    }
  174.    else//sWord is Empty
  175.    {
  176.    pAdd->nWordLen=0;
  177.    pAdd->sWord=NULL;
  178.    }
  179.    pAdd->next=pCur;
  181.    if(pPre==NULL)//link pAdd after the pPre
  182.    m_pHead=pAdd;
  183.    else
  184.    pPre->next=pAdd;
  185.    }
  186.    return 0;
  187. }
  188. /*********************************************************************
  189.  *
  190.  *  Func Name  : operator =
  191.  *
  192.  *  Description:  operator =
  193.  *              
  194.  *
  195.  *  Parameters : 
  196.  *               
  197.  *    
  198.  *  Returns    : 
  199.  *  Author     : Kevin Chang  
  200.  *  History    : 
  201.  *              1.create 2001-11-7
  202.  *********************************************************************/
  203. const CDynamicArray & CDynamicArray::operator =(const CDynamicArray &array)
  204. {
  205.    PARRAY_CHAIN pCur,pAdd,pTail=NULL;//The pointer of array chain
  207.    /*----Added By huangjin@ict.ac.cn 2006-7-23----*/
  208.    //赋值运算符必须加入对自身的判断
  209.    if (this == &array)
  210.    return *this;
  211.    /*---------------------------------------------*/
  212.    
  213.    SetEmpty();
  214.    m_nCol=array.m_nCol;
  215.    m_nRow=array.m_nRow;
  216.    pCur=array.m_pHead;
  217.    while(pCur!=NULL)
  218.    {
  219.    pAdd=(PARRAY_CHAIN)malloc(sizeof(ARRAY_CHAIN));//malloc a new node
  220.    pAdd->col=pCur->col;//get the value
  221.    pAdd->row=pCur->row;
  222.    pAdd->value=pCur->value;
  223.    pAdd->nPOS=pCur->nPOS;
  224.    pAdd->next=NULL;
  225.        pAdd->sWord=NULL;
  226.    /* 
  227. * ----- commented by huangjin@ict.ac.cn 2006-5-29 ------ 
  228. * 
  229. *  if(pCur->nWordLen>=0)
  230. */
  231.    /*----Added By huangjin@ict.ac.cn 2006-5-29----*/
  232.    pAdd->nWordLen=0;
  233.    if(pCur->nWordLen>0)
  234.    /*-----------------------------------------------*/
  235.    {
  236.    pAdd->nWordLen=pCur->nWordLen;
  237.    pAdd->sWord=new char[pAdd->nWordLen+1];    
  238.    strcpy(pAdd->sWord,pCur->sWord);
  239.    }    
  241.    if(pTail==NULL)
  242.    m_pHead=pAdd;//The head element
  243.    else
  244.            pTail->next=pAdd;
  245.        pTail=pAdd;
  246.    pCur=pCur->next;
  247.    }
  248.    return *this;
  249. }
  251. void CDynamicArray::SetEmpty()
  252. {
  253.    PARRAY_CHAIN pCur=m_pHead,pTemp;
  254.    while(pCur!=NULL)//delete the node 
  255.    {
  256.    pTemp=pCur->next;
  257.      if(pCur->nWordLen>0)
  258. delete [] pCur->sWord;
  259.        free(pCur); 
  260.    pCur=pTemp;
  261.    }
  262.    m_pHead=NULL;
  263.    m_nCol=0;
  264.    m_nRow=0;
  265. }
  267. bool CDynamicArray::operator ==(const CDynamicArray &array)
  268. {
  269.    PARRAY_CHAIN pFirst,pSecond;//The pointer of array chain
  270.    if(m_nCol!=array.m_nCol||m_nRow!=array.m_nRow)//Row or Col not equal
  271.    return false;
  272.    
  273.    pFirst=array.m_pHead;
  274.    pSecond=m_pHead;
  275.    while(pFirst!=NULL&&pSecond!=NULL&&pFirst->row==pSecond->row&&pFirst->col==pSecond->col&&pFirst->value==pSecond->value)
  276.    {
  277.    pFirst=pFirst->next;
  278.    pSecond=pSecond->next;
  279.    }
  280.    if(pFirst==NULL&&pSecond==NULL)
  281.         return true;
  282.    return false;
  283. }
  284. /*********************************************************************
  285.  *
  286.  *  Func Name  : GetElement
  287.  *
  288.  *  Description:  Get the element value
  289.  *              
  290.  *
  291.  *  Parameters : nRow: the row number
  292.  *               nCol: the Column number
  293.  *    
  294.  *  Returns    : the element value if found,else Infinite value
  295.  *  Author     : Kevin Zhang  
  296.  *  History    : 
  297.  *              1.create 2002-4-22
  298.  *********************************************************************/
  299. bool CDynamicArray::GetElement(int nRow, int nCol, ELEMENT_TYPE *pRetValue, int *pRetPOS,char *sRetWord)
  300. {
  301.     PARRAY_CHAIN pCur=m_pHead;
  302. *pRetValue=INFINITE_VALUE;
  303. *pRetPOS=0;
  304.    if(nRow>(int)m_nRow||nCol>(int)m_nCol)//Judge if the row and col is overflow
  305.    return false;
  306. /*
  307. #if ROW_FIRST==1
  308.    while(pCur!=NULL&&(nRow!=-1&&(int)pCur->row<nRow||(nCol!=-1&&(int)pCur->row==nRow&&(int)pCur->col<nCol)))
  309. #else
  310.    while(pCur!=NULL&&(nCol!=-1&&(int)pCur->col<nCol||((int)pCur->col==nCol&&nRow!=-1&&(int)pCur->row<nRow)))
  311. #endif
  312.    {
  313.    pCur=pCur->next;
  314.    }
  315. */
  316.    if(m_bRowFirst)
  317.    {
  318.    while(pCur!=NULL&&(nRow!=-1&&(int)pCur->row<nRow||(nCol!=-1&&(int)pCur->row==nRow&&(int)pCur->col<nCol)))
  319.    {
  320.    pCur=pCur->next;
  321.    }
  322.    }
  323.    else
  324.    {
  325.    while(pCur!=NULL&&(nCol!=-1&&(int)pCur->col<nCol||((int)pCur->col==nCol&&nRow!=-1&&(int)pCur->row<nRow)))
  326.    {
  327.    pCur=pCur->next;
  328.    }
  329.    }
  330.    if(pCur!=NULL&&((int)pCur->row==nRow||nRow==-1)&&((int)pCur->col==nCol||nCol==-1))//Find the same position
  331.    {//Find it and return the value
  332. *pRetValue=pCur->value;
  333. if(pRetPOS)
  334. *pRetPOS=pCur->nPOS;
  335.     if(sRetWord)//sWord is not empty
  336. {
  337.    strcpy(sRetWord,pCur->sWord);
  338. }
  339.    }
  340. return true;
  341. }
  343. PARRAY_CHAIN CDynamicArray::GetHead()
  344. {
  345. return m_pHead;
  346. }
  347. //Get the tail Element buffer and return the count of elements
  348. unsigned int CDynamicArray::GetTail(PARRAY_CHAIN *pTailRet)
  349. {
  350.     PARRAY_CHAIN pCur=m_pHead,pPrev=NULL;
  351. //pCur: current node;pPrev:previous node
  352. unsigned int nCount=0;
  353. while(pCur!=NULL)
  354. {
  355. nCount+=1;
  356. pPrev=pCur;
  357. pCur=pCur->next;
  358. }
  359. *pTailRet=pPrev;
  360. return nCount;
  361. }
  363. bool CDynamicArray::SetRowFirst(bool RowFirst)
  364. {
  365. m_bRowFirst=RowFirst;
  366. return true;
  367. }