/*
* 函数原形 int FileCopy(const char* pDestFileName, const char* pSrcFileName);
* 表头文件 #include
* 函数描述 复制文件函数。将 pSrcFileName 文件复制到 pDestFileName 处，
* 如果 pDestFileName 文件存在，将回覆盖此文件。
* 参 数 pSrcFileName，要复制的源文件名
* pDestFileName, 源文件复制后的文件，如果系统中存在此名称的文件，将会覆盖掉！
* 返回值 成功，返回 1
* 失败，返回 0
* 作 者 武立强
* 时 间 2009-02-19
* 备 注 在复制前要先判断目标文件是否存在，否则会覆盖掉已经存在的文件
*/
int FileCopy(const char* pDestFileName, const char* pSrcFileName)
{
assert( NULL != pDestFileName && NULL != pSrcFileName );
FILE *fpDest = NULL;
FILE *fpSrc = NULL;
// 打开源文件, 只读
fpSrc = fopen(pSrcFileName, "rb");
if( NULL == fpSrc )
{
// 打开文件失败
return 0;
}
// 打开目的文件,只写
fpDest = fopen(pDestFileName, "wb");
if( NULL == fpDest )
{
// 打开文件失败
fclose(fpSrc);
return 0;
}
while( !feof(fpSrc) )
{
int nCount = 0; // 读取字节的个数
char szBuf[500] = "";
// 一次读写500个字节,效率还可以！
nCount = fread(szBuf, sizeof(char), 500, fpSrc);
fwrite(szBuf, sizeof(char), nCount, fpDest);
}
fclose(fpDest);
fclose(fpSrc);
return 1;
}
/*
* 函数原形 int CheckFileIsEmpty(const char* _pchFileName);
* 表头文件 #include
* 函数描述 检查一个文件是否为空文件
* 参 数 _pchFileName, 文件名字符串
* 返回值 1，表示文件是空文件
* 0，表示文件非空
* -1，函数执行失败（打开文件失败）
* 作 者 武立强
* 时 间 2009-02-19
* 备 注
*/
int CheckFileIsEmpty(const char* _pchFileName)
{
assert( NULL != _pchFileName );
char chTemp = 0;
int nRead = 0;
FILE * fp = NULL;
// 打开文件， 只读
fp = fopen(_pchFileName, "rb");
if( NULL == fp )
{
return -1;
}
// 读一个字节
nRead = fread(&chTemp, sizeof(char), 1, fp);
if( 1 == nRead )
{
return 1;
}
else
{
return 0;
}
// 关闭文件
fclose(fp);
}
/*
* 函数原形 int CheckIsFileExist(const char* _pchFileName);
* 表头文件 #include
* 函数描述 检查文件是否存在。
* 参 数 _pchFileName, 文件路径名
* 返回值 1，文件存在
* 0，文件不存在
* 作 者 武立强
* 时 间 2009-02-19
* 备 注
*/
int CheckIsFileExist(const char* _pchFileName)
{
assert( NULL != _pchFileName );
FILE * fp = NULL;
fp = fopen(_pchFileName, "r");
if( NULL == fp)
{
return 0;
}
else
{
return 1;
}
fclose(fp);
}
/*
* 函数原形 int CheckIsLegalUser(const char* _pchFileName, const struct stUserInfo* _pstUserInfo);
* 表头文件 #include
* #include
* 函数描述 用户登陆验证，校验用户信息的合法性。此函数主要用于用户登陆时用户名，密码的验证。将 _pstUserInfo 中的
* 用户名，密码，和密码文件_pchFileName中存储的用户信息进行比较。
* 参 数 _pchFileName，存储用户名、密码的文件，此文件中，每一个用户信息 （用户名，密码）占一行，
* 且用户名和密码用 Tab 键分割.
* stUserInfo，用户信息结构体。定义如下：
* struct stUserInfo
* {
* char szUserName[21];
* char szPassword[21];
* };
*
* 返回值 成功，合法用户返回 0, 非法用户 返回 1
* 失败，返回 -1
* 作 者 武立强
* 时 间 2009-02-20
* 备 注
*/
int CheckIsLegalUser(const char* _pchFileName, const struct stUserInfo* _pstUserInfo)
{
assert( NULL != _pstUserInfo && NULL != _pchFileName );
FILE * fp = NULL;
fp = fopen(_pchFileName, "r");
if( NULL == fp )
{
printf("Open %s file error : CheckIsLegalUser \n", _pchFileName);
return (-1);
}
while( !feof(fp) )
{
char szName[21] = "";
char szPassword[21] = "";
fscanf(fp, "%s%s", szName, szPassword);
if( !strcmp(_pstUserInfo->szUserName, szName) && !strcmp(_pstUserInfo->szPassword, szPassword) )
{
// 用户名密码和密码文件中一致
return 0;
}
}
fclose(fp);
return 1;
}
/*
* 函数原形 int WriteLogToFile(const char* _pchFileName, const char* _pchLogStr);
* 表头文件 #include
* 函数描述 将日志字符串写到文件中
* 参 数 _pchFileName，日志文件名
* _pchLogStr， 具有一定格式的日志字符串
* 返回值 成功，返回 0
* 失败，返回 -1
* 作 者 武立强
* 时 间 2009-02-20
* 备 注 需要自己组织一个具有一定格式的日志字符串
*/
int WriteLogToFile(const char* _pchFileName, const char* _pchLogStr)
{
assert( NULL != _pchFileName && NULL != _pchLogStr );
FILE * fp = NULL;
// 打开文件, 追加的方式
fp = fopen(_pchFileName, "a");
if( NULL == fp )
{
printf("open %s error:WriteLogToFile \n", _pchFileName);
return (-1);
}
// 写文件
fprintf(fp, "%s\n", _pchLogStr);
fclose(fp);
return 0;
}
/*
* 函数原形 char * GetCurrentTimeString(char* _pchTimeStr);
* 表头文件 #include
* #include
* #include
* 函数描述 当前系统时间转换为字符串格式。生成的字符串格式为："2009-2-21 9:39:29"（18个字符）
* 参 数 _pchTimeStr，存放转换后的字符串。要有足够的空间来存放转换后的字符串
* 返回值 返回_pchTimeStr首地址。
* 作 者 武立强
* 时 间 2009-02-21
* 备 注 使用前要将_pchTimeStr所指向的内容全部清零(必须清零,要不会出错)
*/
char * GetCurrentTimeString(char* _pchTimeStr)
{
assert( NULL != _pchTimeStr );
time_t timep = 0;
struct tm *p = NULL;
char szTemp[5] = "";
time(&timep);
p=localtime(&timep); /*取得当地时间*/
// 年
strcat(_pchTimeStr, itoa(1900 + p->tm_year, szTemp, 10) );
strcat(_pchTimeStr, "-");
// 月
strcat(_pchTimeStr, itoa(1 + p->tm_mon, szTemp, 10) );
strcat(_pchTimeStr, "-");
// 日
strcat(_pchTimeStr, itoa(p->tm_mday, szTemp, 10) );
strcat(_pchTimeStr, " ");
// 时
strcat(_pchTimeStr, itoa(p->tm_hour, szTemp, 10) );
strcat(_pchTimeStr, ":");
// 分
strcat(_pchTimeStr, itoa(p->tm_min, szTemp, 10) );span style=fclosecolor: rgb(255, 0, 0);color: rgb(255, 0, 0);;color: rgb(0, 0, 204);
color: rgb(255, 0, 255);
color: rgb(0, 0, 204);
strcat(_pchTimeStr, ":");
// 秒
strcat(_pchTimeStr, itoa(p->tm_sec, szTemp, 10) );
return _pchTimeStr;
}
/*
* 函数原形 int GetCurrentTimeOneElements(const int nFlag);
* 表头文件 #include
* #include
* #include
* 函数描述 得到当前系统时间的一个基本元素。例如，年、月、日、时、分、秒、星期
* 参 数 nFlag，表示位，只能是 0 -6 之间的正整数。
* 返回值 nFlag = 0，返回当前年
* nFlag = 1，返回当前月（1-12）
* nFlag = 2，返回当前日（1-31）
* nFlag = 3，返回当前时（0-23）
* nFlag = 4，返回当前分（0-59）
* nFlag = 5，返回当前秒（0-59）
* nFlag = 6，返回当前星期（1-7）
* 当nFlag为其他值是，返回 -1
*
* 作 者 武立强
* 时 间 2009-02-21
* 备 注
*/
int GetCurrentTimeOneElements(const int nFlag)
{
if( nFlag < 0 || nFlag > 6)
{
return (-1);
}
time_t timep = 0;
struct tm *p = NULL;
const int arrWeekDay[7] = {7,1,2,3,4,5,6};
time(&timep);
p=localtime(&timep); /*取得当地时间*/
switch( nFlag )
{
case 0:
// 以整数形式返回年份
return (1900 + p->tm_year);
break;
case 1:
// 月
return (1 + p->tm_mon);
break;
case 2:
// 日
return (p->tm_mday);
break;
case 3:
// 时
return (p->tm_hour);
break;
case 4:
// 分
return (p->tm_min);
break;
case 5:
// 秒
return (p->tm_sec);
break;
case 6:
// 星期
return ( arrWeekDay[p->tm_wday] );
break;
default:
return (-1);
}
return (-1);
}
/*
* 函数原形 char * IniFileAnalyse(const char* _pchFileName, const char* _pchArea, const char* _pchKey, char* _pchValue);
* 表头文件 #include
* #include
* 函数描述 固定格式的文件解析。文件建议.ini 后缀，当然也可以是其他的文件,文件的格式
* 要求如下：example.ini
* [login] // [域名]
* name=admin // key = value
* password=888888
* ...
* 文件可以有多个域，但不能有重名的域。
* 每一行可以有空格,
* 每一行长度不能超过500个字符
* 参 数 _pchFileName, 文件名
* _pchArea，域名
* _pchKey，要查找的关键字
* _pchValue，存放找到的结果，要有足够的空间来 存放找到的结果!
* 返回值 如果查找成功，返回第一个找到_pchKey所对应的_pchValue串的首地址
* 没有找到后函数调用失败都返回 NULL
* 作 者 武立强
* 时 间 2009-02-22
* 备 注 用到了StringFilter()函数。
*/
char * IniFileAnalyse(const char* _pchFileName, const char* _pchArea, const char* _pchKey, char* _pchValue)
{
assert( NULL != _pchFileName && NULL != _pchArea && NULL != _pchKey && NULL != _pchValue );
FILE * fp = NULL;
char szTemp[501] = ""; // 支持文件一行最多500个字符
int nKeyLength = strlen(_pchKey);
// 打开文件,只读
fp = fopen(_pchFileName, "r");
if( NULL == fp )
{
printf("IniFileAnalyse: open %s file error!\n");
return NULL;
}
while( !feof(fp) )
{
// 读取一行数据, 将最后的那个 '\n' 也读进来了!
fgets(szTemp, sizeof(szTemp), fp);
StringFilter(szTemp, ' '); // 过滤所有空格
StringFilter(szTemp, '\n'); // 过滤 '\n'
if( '[' == szTemp[0] )
{
// 找到一个域的开始
// 将 '[' 和 ']' 分别过滤掉
StringFilter(szTemp, '[');
StringFilter(szTemp, ']');
}
else
{
continue;
}
if( !strcmp(szTemp, _pchArea) )
{
// 找到一个域
;
}
else
{
continue;
}
while( !feof(fp) )
{
fgets(szTemp, sizeof(szTemp), fp);
StringFilter(szTemp, ' '); // 过滤所有空格
if( '[' == szTemp[0] )
{
// 已经到了下一个域了,还没有找到,直接返回
fclose(fp);
return NULL;
}
// 比较前 nKeyLength 个是否相等
else if( !strncmp(szTemp, _pchKey, nKeyLength) )
{
// 找到了_pchKey相同的字符串
StringFilter(szTemp, '\n'); // 过滤最后的那个 '\n'
strcpy(_pchValue, (szTemp + nKeyLength + 1));
fclose(fp);
return _pchValue;
}
}
}
fclose(fp);
return NULL;
}
/*
* 函数原形 char * StringMove(char* _pchDest, const char* _pchSrc, int nNumber);
* 表头文件 #include
* #include
* 函数描述 字符串循环移动。将字符串循环向左或向右移动 nNumber 个字符。
* 参 数 _pchSrc，要移动的原串
* nNumber，移动的位数，当 nNumber > 0 时，向左移动， nNumber < 0时，向右移动
* _pchKey，要查找的关键字
* _pchDest，存放移动后的字符串，要有足够的空间来存放处理后的字符串。
* 返回值 返回 _pchDest 字符串的首地址。
* 作 者 武立强
* 时 间 2009-02-22
* 备 注 此函数可用于简单的加密和解密运算。
*/
char * StringMove(char* _pchDest, const char* _pchSrc, int nNumber)
{
assert( NULL != _pchDest && NULL != _pchSrc);
int nSrcLen = strlen(_pchSrc);
if( nNumber >= 0 )
{
// 向左移动
nNumber = nNumber % nSrcLen; // 处理移动的位数大于字符串长度时的情况
strcpy(_pchDest, _pchSrc + nNumber);
strncat(_pchDest, _pchSrc, nNumber);
}
else
{
//向右移动
nNumber = (0 - nNumber);
nNumber = nNumber % nSrcLen;
strcpy(_pchDest, _pchSrc + (nSrcLen - nNumber));
strncat(_pchDest, _pchSrc, nSrcLen - nNumber);
}
return _pchDest;
}
/*
* 函数原形 void StringExclusiveEncription(char* _pchSrc, int _nLen, char _chKey);
* 表头文件 #include
* #include
* 函数描述 异或运算加密函数,直接修改原串。
* 将一个字符串的每一个字符和一个特定的字符异或运算
* 第一次异或----加密
* 第二次异或----解密
* 参 数 _pchSrc，要加密的原串
* _nLen, 原串的长度，用 strlen() 函数可以得到。
* _chKey，加密的密钥
* 返回值 无返回值
* 作 者 武立强
* 时 间 2009-02-22
* 备 注 Exclusive:异或。Encription:加密
*/
void StringExclusiveEncription(char* _pchSrc, int _nLen, char _chKey)
{
assert( NULL != _pchSrc );
for(int i=0; i<_nLen; i++)
{
_pchSrc[i] = _pchSrc[i] ^ _chKey; // 异或运算
}
return ;
}
/*
* 函数原形 void StringInverseEncription(char* _pchSrc, int _nLen);
* 表头文件 #include
* #include
* 函数描述 取反运算加密函数,直接修改原串。
* 将一个字符串的每一个字符取反
* 第一次取反----加密
* 第二次取反----解密
* 参 数 _pchSrc，要加密的原串
* _nLen, 原串的长度，用 strlen() 函数可以得到。
* 返回值 无返回值
* 作 者 武立强
* 时 间 2009-02-22
* 备 注 Inverse:相反的。Encription:加密
*/
void StringInverseEncription(char* _pchSrc, int _nLen)
{
assert( NULL != _pchSrc );
for(int i=0; i<_nLen; i++)
{
_pchSrc[i] = ~_pchSrc[i]; // 取反运算
}
return ;
}
/*
* 函数原形 int GetMaxNumber(int _nArr[], int _nLen);
* 表头文件 #include
* 函数描述 得到一个数组中最大的数 (冒泡法)
* 参 数 _nArr，数组名
* _nLen, 数组的长度
* 返回值 数组中最大的数
* 作 者 武立强
* 时 间 2009-02-22
* 备 注
*/
int GetMaxNumber(int _nArr[], int _nLen)
{
assert( NULL != _nArr );
int nTemp = _nArr[0];
for(int i=0; i<_nLen; i++)
{
if( nTemp < _nArr[i] )
{
nTemp = _nArr[i];
}
}
return nTemp;
}
/*
* 函数原形 int GetMaxNumber(int _nArr[], int _nLen);
* 表头文件 #include
* 函数描述 得到一个数组中第二大的数 (冒泡法)
* 参 数 _nArr，数组名
* _nLen, 数组的长度
* 返回值 数组中最大的数
* 作 者 武立强
* 时 间 2009-02-22
* 备 注
*/
int GetSecondMaxNumber(int _nArr[], int _nLen)
{
assert( NULL != _nArr );
int nFirst = _nArr[0];
int nSecond = _nArr[0];
// 得到最大的数
for(int i=0; i<_nLen; i++)
{
if( nFirst < _nArr[i] )
{
nFirst = _nArr[i];
}
}
// 得到第二大的数
for(i=0; i<_nLen; i++)
{
if( nSecond < _nArr[i] && _nArr[i] != nFirst )
{
nSecond = _nArr[i];
}
}
return nSecond;
}
/*
* 函数原形 char * GetSubString(char * _pchSubStr, const char* _pchStr, int _nStart, int _nEnd);
* 表头文件 #include
* #include
* 函数描述 得到一个字符串中的子串
* 参 数 _pchStr，原字符串
* _nStart, 原字符串开始下标
* _nEnd，原字符串结束下标
* _pchSubStr，存放找到的子串，要有足够的空间来存放处理后的子串。
* 返回值 _pchSubStr子串的首地址。
* 作 者 武立强
* 时 间 2009-02-22
* 备 注
*/
char * GetSubString(char * _pchSubStr, const char* _pchStr, int _nStart, int _nEnd)
{
assert( NULL != _pchSubStr && NULL != _pchStr );
int nSrcLen = strlen(_pchStr);
char* _pchFirst = _pchSubStr;
// 逻辑判断, 是否超出原串的范围
if( _nStart < 0 || _nEnd < 0 )
{
return NULL;
}
else if( _nStart >= nSrcLen || _nEnd >= nSrcLen )
{
return NULL;
}
else if( _nStart > _nEnd )
{
return NULL;
}
for(int i=0; i<(_nEnd - _nStart + 1); i++)
{
*_pchSubStr++ = *(_pchStr++ + _nStart);
}
*_pchSubStr = '\0';
return _pchFirst;
}
/*
* 函数原形 char * MuitCharFilterToOne(char* _pchStr, char _chKey);
* 表头文件 #include
* 函数描述 直接修改原串，将字符串_pchStr中的多个chKey过滤成一个
* 参 数 _pchStr，原字符串
* _chKey，要过滤的字符
* 返回值 _pchStr串的首地址。
* 作 者 武立强
* 时 间 2009-02-22
* 备 注 MuitCharFilterToOne(str, char ' '); 将多个空格过滤成一个
*/
char * MuitCharFilterToOne(char* _pchStr, char _chKey)
{
assert( NULL != _pchStr);
char* pchFirst = _pchStr;
int nCount = 0;
int nFind = 0;
while( '\0' != *_pchStr )
{
if( 0 == nFind && _chKey == *_pchStr )
{
nFind = 1;
*(_pchStr - nCount) = *_pchStr; // 向前移动
}
else if( 1 == nFind && _chKey == *_pchStr )
{
nCount++;
}
else
{
nFind = 0;
*(_pchStr - nCount) = *_pchStr; // 向前移动
}
_pchStr++;
}
*(_pchStr - nCount) = '\0';
return pchFirst;
}
/*
* 函数原形 char * GetKeyStr(char* _pStr);
* 表头文件 #include
* #include
* #include
* 函数描述 得到键盘的字符串值
* 参 数 _pStr，存放生成的字符串
* 返回值 _pStr串的首地址。
* 作 者 武立强
* 时 间 2009-04-03
* 备 注
*/
char * GetKeyStr(char* _pStr)
{
assert(NULL != _pStr);
char ch = getch();
if( ch < 0 )
{
ch = getch();
if( 72 == ch )
{
strcpy(_pStr, "up");
}
else if( 80 == ch )
{
strcpy(_pStr, "down");
}
else if( 75 == ch )
{
strcpy(_pStr, "left");
}
else if( 77 == ch )
{
strcpy(_pStr, "right");
}
}
else if( 13 == ch )
{
strcpy(_pStr, "enter");
}
else if( 27 == ch )
{
strcpy(_pStr, "esc");
}
else if( 9 == ch )
{
strcpy(_pStr, "tab");
}
else if( 8 == ch )
{
strcpy(_pStr, "backspace");
}
else if( 32 == ch )
{
strcpy(_pStr, "space");
}
else
{
_pStr[0] = ch;
_pStr[1] = '\0';
}
return _pStr;
}
/*
* 函数原形 void * memmove(void* _pDest, const void* _pSrc, int _nCount);
* 表头文件 #include
* 函数描述 内存移动函数,将内存中的内容从一个地方移动到另一个地方
* 参 数 _pSrc，源内存首地址
* _pDest,目的内存首地址
* 返回值 目的内存首地址
* 作 者 武立强
* 时 间 2009-04-08
* 备 注
*/
void * memmove(void* _pDest, const void* _pSrc, int _nCount)
{
assert( _pDest && NULL != _pSrc);
char* pDest = (char*)_pDest;
char* pSrc = (char*)_pSrc;
for(int i=0; i<_nCount; color: rgb(0, 0, 204); nSrcLen color: rgb(0, 0, 204); nCountbrtabspan style=i++)
{
pDest[i] = pSrc[i];
pSrc[i] = '\0';
}
return _pDest;
}
/*
* 函数原形 void * memcpy(void* _pDest, const void* _pSrc, int _nCount);
* 表头文件 #include
* 函数描述 内存拷贝函数,将内存中的内容从一个地方拷贝到另一个地方
* 参 数 _pSrc，源内存首地址
* _pDest,目的内存首地址
* 返回值 目的内存首地址
* 作 者 武立强
* 时 间 2009-04-08
* 备 注
*/
void * memcpy(void* _pDest, const void* _pSrc, int _nCount)
{
assert( _pDest && NULL != _pSrc);
char* pDest = (char*)_pDest;
char* pSrc = (char*)_pSrc;
for(int i=0; i<_nCount; i++)
{
pDest[i] = pSrc[i];
}
return _pDest;
}
/*
* 函数原形 int CheckIsEmailStr(const char* _pStr);
* 表头文件 #include
* 函数描述 检查字符串是否是邮件格式, 即 xxx@xxx格式字符串
* 参 数 _pStr，字符串的首地址
* 返回值 0, 正确
* -1,错误
* 作 者 武立强
* 时 间 2009-04-08
* 备 注
*/
int CheckIsEmailStr(const char* _pStr)
{
assert(NULL != _pStr);
if( '\0' == *_pStr)
{
return (-1);
}
else
{
_pStr++;
}
while( '\0' != *_pStr )
{
if( '@' == *_pStr && '\0' != *(_pStr+1) )
{
return 0;
}
_pStr++;
}
return (-1);
}
/*
* 函数原形 int IsPalindrome(const char* _pStr);
* 表头文件 #include
* #include
* #include
* 函数描述 判断一个字符串是否为回文，用栈的思路实现。
* 回文，即 abcba 形式，从前后看，字符串都一样。
* 参数 _pStr，要判断的字符串
* 返回值 0, 回文
* -1, 非回文
* 注释
*/
int IsPalindrome(const char* _pStr)
{
assert( NULL != _pStr );
int nStrLen = 0; // 标志_pStr 的长度
int nHalfLen = 0; // 取其一半长度
int nStartIndex = 0; // 开始比较的下标
char* pData = NULL; // 存储数据首地址
nStrLen = strlen(_pStr);
if( 1 == nStrLen )
{
return 0; // 就一个字符，是回文
}
nHalfLen = nStrLen / 2; // 两个整数相除，结果取整
pData = (char*)malloc(sizeof(char)*(nHalfLen + 1));
if( NULL == pData )
{
printf("malloc error...");
return (-1);
}
// 将前一半字符取出
for(int i=0; i<nHalfLen; i++)
{
pData[i] = _pStr[i];
}
pData[i] = '\0';
if( 0 == nStrLen%2 )
{
// _pStr 长度为偶数时
nStartIndex = nHalfLen;
}
else
{
// _pStr 长度为奇数时
nStartIndex = nHalfLen + 1;
}
// 逆序比较
for(i= nHalfLen -1; i>=0; i--)
{
if( pData[i] != _pStr[nStartIndex] )
{
free(pData); // 返回前释放内存
return (-1);
}
nStartIndex++;
}
free(pData);
return 0;
}
/*
* 函数原形 int CheckBracketsIsMatch(const char* _pStr);
* 表头文件 #include
* #include
* #include
* 函数描述 检查一个字符串中的括号是否匹配（用栈的思路实现）
* 参数 _pStr，要判断的字符串
* 返回值 0, 匹配
* -1, 不匹配
* 注释
*/
int CheckBracketsIsMatch (const char* _pStr)
{
assert( NULL != _pStr );
// 过滤字符串，只保留括号字符
char* pStr = (char*)malloc(strlen(_pStr) + 1);
if( NULL == pStr )
{
printf("malloc error...");
return (-1);
}
char* pStrFirst = pStr;
while( '\0' != *_pStr)
{
if( *_pStr == '[' || *_pStr == ']'
|| *_pStr == '{' || *_pStr == '}'
|| *_pStr == '(' || *_pStr == ')')
{
*pStr = *_pStr ;
pStr++;
}
_pStr++;
}
*pStr = '\0';
pStr = pStrFirst; // 将指针指向开头
int nStrLen = 0; // 标志 pStr 的长度
int nHalfLen = 0; // 取其一半长度
int nStartIndex = 0; // 开始比较的下标
char* pData = NULL;
nStrLen = strlen(pStr);
// 判断长度
if( 1 == nStrLen || 0 == nStrLen )
{
free(pStr);
return (-1); // 肯定不匹配
}
else if( 0 != nStrLen%2 )
{
// 长度为奇数,肯定不匹配
free(pStr);
return (-1);
}
nHalfLen = nStrLen / 2; // 两个整数相除，结果取整
pData = (char*)malloc(sizeof(char)*(nHalfLen + 1));
if( NULL == pData )
{
printf("malloc error...");
free(pStr);
return (-1);
}
// 将前一半字符取出
for(int i=0; i<nHalfLen; i++)
{
pData[i] = pStr[i];
}
pData[i] = '\0';
nStartIndex = nHalfLen;
printf("----->%s \n", pStr);
printf("----->%s \n", pData);
// 逆序比较
for(i= nHalfLen -1; i>=0; i--)
{
if( ('[' == pData[i] && ']' != pStrspan style=span style=;color: rgb(0, 0, 204);[nStartIndex])
|| ('{' == pData[i] && '}' != pStr[nStartIndex])
|| ('(' == pData[i] && ')' != pStr[nStartIndex])
)
{
free(pStr);
free(pData); // 返回前释放内存
return (-1); // 不匹配
}
nStartIndex++;
}
free(pStr);
free(pData);
return 0;
}
/**************************************************
* 函数名: BSearch
* 参数:
* 形参:
* _pList : 顺序存储结构的线性表
* _key : 查找关键字
* _nLow : 查找范围下界
* _nHigh : 查找范围上界
* 返回值: 查找结果，-1表示查找失败，否则为查找到的元素下标
* 功能:
* 对顺序存储结构的线性表进行递归二分查找
* 作者: 左建华
* 编写明细:
* 2008-05-29 Created 左建华
*
**************************************************/
int BSearch(SeqList* _pList, DataType _key, int _nLow, int _nHigh)
{
if( _nLow>_nHigh )
{
return -1;
}
int nMiddle = (_nLow+_nHigh)/2;
if( _pList->data[nMiddle] == _key )
{
return nMiddle;
}
if( _pList->data[nMiddle] > _key )
{
return BSearch( _pList, _key, _nLow, nMiddle-1 );
}
else
{
return BSearch( _pList, _key, nMiddle+1, _nHigh );
}
}
/*
* 函数原形 void DeleteRepeat(LinkList* _pHead);
* 表头文件 #include
* #include
* 函数描述 删除链表中重复的数据，只保留一个
* 参数 _pHead，链表头结点指针
* 返回值 void
* 注释 例如，链表中数据11123，运行此函数后数据变成123
*/
void DeleteRepeat(LinkList _pHead)
{
assert( NULL != _pHead );
Node* pHere = NULL;
Node* pHereLast = NULL; // 当前结点
Node* pNode = _pHead; // 当前结点的上一个结点
while(pNode)
{
pHere = pNode->next;
pHereLast = pNode;
while(pHere) // 从pHere 开始，一直到链表结束
{
if(pHere->data == pNode->data)
{
// 重复数据结点,删除
pHereLast->next = pHere->next;
free(pHere);
pHere = pHereLast;
}
pHereLast = pHere;
pHere = pHere->next;
}
pNode = pNode->next;
}
}
/*
* 函数原形 int Convert(int _nNum, int _nB, char* _pOutStr);
* 表头文件 #include
* 函数描述 将十进制的 Num (只能是正数)转换成 B 进制数，
* 以字符串的形式输出结果
* 参数 _nNum，使进制数
* _nB，表示要转换为 B 进制
* _pOutStr，（输出参数）转换后的字符串，要有足够的空间容纳转换后的字符串
* 返回值 0，成功
* -1，失败
* 注释 目前不支持负数。 思路：Num 除 B 取余到排
*/
int Convert(int _nNum, int _nB, char* _pOutStr)
{
if( _nNum < 0 )
{
return (-1);
}
if( 0 == _nNum )
{
*_pOutStr = '0';
return 0;
}
int nTemp = _nNum;
int nLen = 0; //转换后的数的位数
// 计算转换后的数的位数
while( 1 != nTemp )
{
nTemp /= 2;
nLen++;
}
nLen += 1;
int* pB = (int*)malloc(sizeof(int)*nLen);
if( NULL == pB )
{
return (-1);
}
nTemp = _nNum;
for(int i=0; i<nLen; i++)
{
pB[i] = nTemp % 2;
nTemp /= 2;
}
// 输出转换后的 B 进制数(逆序输出)
for(i=nLen-1; i>=0; i--)
{
_pOutStr[(nLen-1) - i] = pB[i] + '0'; // 将整数转换为字符
}
_pOutStr[nLen] = '\0';
free(pB);
return 0;
}
|
