字符串基本处理算法

最近想写写字符串处理方面的东西。前面已经写写了字符串分割函数的实现。下面再将几种常见的字符串处理算法实现了下。

第一个为统计字符串的长度函数，很简单，定义一个指针指向字符串首位，然后从头遍历到字符串的尾部，遇到'\0'就停止，同时定义一个变量累加。下面直接贴代码：

int stringlen(char *str)
{
	int length=0;
	while(*str++!='\0')
		length++;
	return length;
}

第二函数为字符串拷贝函数strcpy的实现，一般思路就是定义两个指针，一个指针指向源字符串首位，另一个指向待复制的字符串数组，将源字符串的字符依次赋值给目的字符串。这里实现了两个版本的alpha版本的就是简单的复制，beta版本加入了内存重叠检测，检查目的与源的长度是否匹配，这个版本的更加安全。代码实现如下：

char* strcopyalpha( char *src,char *dst)
{
	assert(dst!= NULL && src!= NULL);   
    char *ret = dst; 
	do{
        *dst++=*src++;
	}while(*src!='\0');
    return ret;
}

char* strcopybeta(char *src,char *dst)
{
  assert(dst != NULL && src != NULL);
  char *ret = dst;
  int cnt=stringlen(src)+1;

  if (dst >= src && dst <= src+cnt-1)
  {
        dst = dst+cnt-1;
        src = src+cnt-1;
        while (cnt--)
            *dst-- = *src--;
    }
    else    
    {
        while (cnt--)
            *dst++ = *src++;
    }   
    return ret;
}

第三个函数是字符串反转函数的实现，由于本函数实现的时候，是将字符互换，所以先定义了一个字符互换函数swap(char *str,int i,int j)。这里也实现两个版本的函数，alpha版本的函数只是简单地进行反转，不考虑单词可读性的问题，算法的主要思想就是，两个动态坐标begin与end。begin赋值为0，end赋值为字符串的长度减一；然后以begin与end作为字符数组的下标，并互换，然后begin后移，end前移，终止条件为begin与end相等。

然后beta版本加入单词次序调整，先利用alpha版本进行整个字符串的反转，然后对每个单词处理，目前区别单词主要是，遇到空格、‘\0’进行单词的反转。然后再参考具体代码进行理解：

字符互换函数：

void swap(char *str,int i,int j)
{
	char temp;
	temp = str[i];
	str[i] = str[j];
	str[j] = temp;
}

字符串反转函数：

char* reversestralpha(char *str,int begin,int end)
{
	char *ret;

	ret=str;
	
	if(str!=NULL)
	   while(begin<=end){
		  swap(str,begin,end);
		  begin++;
		  end--;
	   }
	return ret;
}

char* reversestrbeta(char *str)
{
	int i,j;
	char *ret;

	int begin=0,end=0;
	int length=stringlen(str)-1;
    
	ret=str;

	reversestralpha(str,0,length);
    printf("%s\n",str);
	for(i=0;i<length;i++)
	{
		if(str[i]==' '||str=='\0')
		{
			end=i-1;
			if(begin<end)
			{
                reversestralpha(str,begin,end);
			}
			begin=i+1;
		}
		/*else if(!isalpha(str[i]))
		{
           begin=i+1;
		}*/

	}
	return ret;
}

第四个函数是对字符串中重复字符进行统计。本函数实现同样是两个版本，两个版本都可以达到要求，但是算法的复杂度不同。首先，看第一种，思路最简单，先固定一个字符分别与其他的字符相比较，相同则累加，不同则不进行累加，同时找出最大的值，这个算法需要两层循环，算法的复杂度为O(n*n)。

再看beta版本的函数，首先定义一个整形的数组alpha，长度为26，初始化为0，这个数组用以存储各个字符出现的次数，然后再定义一个index变量用来表示字符，然后遍历字符串为index赋值为str[i]-'a'，这样就完成了26个下标的表示。然后数组下标相同累加，这样就将所有的字符出现的频数统计出来存储到了数组alpha中。

下面看看代码的实现：

int maxcharalpha(char *str)
{
	int i,j,flag;
	int count=0;
	int max=0;
	int length=stringlen(str);

	for(i=0;i<length;i++)
	{
		for(j=0;j<length;j++)
		{
            if(str[i]==str[j])
				++count;
		}
		if(count>max)
		{
		   max=count;
		   flag=i;
		}
		count=0;
	}
	printf("%c:%d\n",str[flag],max);
	return max;
}

int maxcharbeta(char *str)
{
	int alpha[26]={0};
	int i;
	int length=stringlen(str);
    int index;
	int max,min,maxflag,minflag;

	for(i=0;i<length;i++)
	{
		if(isalpha(str[i]))
		{
            index=str[i]-'a';
			alpha[index]++;
		}
	}
    for(i=0;i<26;i++)
	{
		if(alpha[i]!=0)
		{
			max=min=alpha[i];
			maxflag=minflag=i;
			break;
		}
	}
	/**Find max character**/
	for(i=0;i<26;i++)
	{
		if(alpha[i]!=0)
		{
			if(alpha[i]>max)
			{
				 max=alpha[i];
				 maxflag=i;
			}
		}
	   /**Find min character**/
		if(alpha[i]!=0)
		{
			if(alpha[i]<min)
			{
				min=alpha[i];
				minflag=i;
			}
		}
	}
	if(maxflag!=minflag)
	       printf("max:\n%c:%d\nmin:\n%c:%d\n",maxflag+'a',max,minflag+'a',min);
	else
		printf("two type characters and equal\n");
    return max;		
}

到此四个简单的函数完全实现了，进行测试：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<ctype.h>

/*添加函数在此处*/
int main()
{
	char str[1024];
	char test[1024];
	printf("string you wanna:\n");
	scanf( "%[^\n]",str);

    /**Test string function**/
	reversestrbeta(str);
	printf("reversestr:\n%s\n",str);
	strcopybeta(str,test);
	printf("%s:%d\n",test,stringlen(test));
	maxcharbeta(str);

}