leetcode字符串题

字符串算法

• 字符串翻转
• 字符串旋转
• 数字转字符串
• 字符串转数字
• 回文字符串判断
• 字符串包含
• 字符串删除
• 字符串哈希
• 字符串压缩
• 十进制数转十六进制数
• 字符串替换
• 字符串匹配
• 第一个只出现一次的字符

字符串翻转

第一种方法：

#include <stdio.h>
#include <string.h>
 
char * reverse(char *s ,int len, char *str)
{
    int i=0;
    for(;i<len;i++)
    {
        str[i] = s[len-1-i];
    }
    return str;
}

int main ()
{
   char str[12] = "Hello";
   int  len;
   len = strlen(str);
   printf("初始字符串：%s
",str);
   
   char str1[len];
   reverse(str,len,str1);
   printf("翻转后的字符串：%s",str1);
   return 0;
}

第二种方法：

#include <stdio.h>  
#include <string.h>  
  
  
char *reverse(char *s)  
{  
    char t, *p = s,*q = (s + (strlen(s) - 1));
  
    while (p < q)                       
    {  
        t = *p;                         
        *p++ = *q;  
        *q-- = t;  
    }  
    return(s);  
}  
  
int main()  
{  
     char str[] = "abcdefw";
     printf("初始字符串：'%s'
",str);
     printf("翻转后的字符串：'%s'
", reverse(str));  
     return 0;  
}

字符串旋转

旋转分为左移和右移。

#include <stdio.h>
#include <string.h>
 
void left(char *s ,int len)
{
    char t = s[0];
    int i;
    for (i = 1;i<len;i++)
    {
        s[i-1] = s[i];
    }
    s[len-1] = t;
}

void right(char *s ,int len)
{
    char t = s[len-1];
    int i;
    for (i = len - 1;i>0;i--)
    {
        s[i] = s[i-1];
    }
    s[0] = t;
}


int main ()
{
   char str1[12] = "Hello";
   char str2[12] = "world";
   int  len1,len2 ;
   len1 = strlen(str1);
   len2 = strlen(str2);
   
   
   //开始左移位字符串
   printf("初始字符串：%s
",str1);
   int i = 0;
   for(;i<len1;i++)
   {
           left(str1,len1);
           printf("第%d次移位字符串的结果：%s
",i+1,str1);
   }


   //开始右移位字符串
   printf("初始字符串：%s
",str2);
   i = 0;
   for(;i<len2;i++)
   {
           right(str2,len2);
           printf("第%d次移位字符串的结果：%s
",i+1,str2);
   }
   return 0;
}

数字转字符串

#include <stdio.h>  
#include <string.h>  

//数字转换为字符串
char* hitoa(char *a,int num, int len)
{

    int temp; 
    int ti = num;
    int i = 0, j = 0;
   

    while (ti)  {
        a[i] = ti%10 + '0';     //取最后一个数，并转换成ASCII编码值保存到字符数组中
        i++;                    //向后移动一位，保存下一个字符
        ti /= 10;               //取得已经去掉几位的整数
    }  
    a[i] = '';                //这里一定要记住最后的''
    i -= 1;                     //这里i也要注意是到最后一个非''字符进行反转
    for (; j < i;) {            //把得到的字符串反转一下
        temp= a[i];
        a[i--] = a[j];
        a[j++] = temp;
      
    }
    return a;
}

//计算数字位数
int Count(n){
    int total = 0;
     while(n)
    {
        n /= 10;
        ++total;
    }
    return total;
}

int main()  
{      
     int n = 2324332;
     int count = Count(n);
     printf("%d为：%d位数
",n,count);
     char str[count];
     hitoa(str,n,count);
     printf("转换后的字符串：%s
", str);
     return 0;  
}

字符串转数字

#include <stdio.h>
#include <string.h>
#define MaxValue 2147483647
#define MinValue -2147483648
int StringToint32(char s[])
{


      //检测字符串是否为空
      if (strlen(s) == 0)
      {
        return 0;
      }

      int value = 0;    //存储最后的数字
      int i = 0;        //字符串下标

      //检测正负标记
      int sign = 1;            //sign为数字正负标记，sign>0为正，反之为负，默认为正。
      if (s[0] == '+' || s[0] == '-')
      {
        if (s[0] == '-')
          sign = -1;
        i++;            //当存在标记，则从下标为1的位置开始
      }

      while (i < strlen(s))
      {
        int c = s[i] - '0';  //当前的数字

        //当发生正溢出时，返回最大值，int类型最大值为2147483647
        if (sign > 0
          && (value > MaxValue / 10
            || (value == MaxValue / 10
              && c >= MaxValue % 10)))
        {
          value = MaxValue;
          break;
        }
        //当发生负溢出时，返回最小值，int类型最小值为-2147483648
        else if (sign < 0
          && (value > -(MinValue / 10)
            || (value == -(MinValue / 10)
              && c >= -(MinValue % 10))))
        {
          value = MinValue;
          break;
        }

        //转换字符串
        value = value * 10 + c;

        i++;
      }

      return sign > 0? value: value == MinValue ? value : -value;
}

int main ()
{
   char str1[] = "-4242342";
   printf("%d
",StringToint32(str1));
   char str2[] = "3234";
   printf("%d
",StringToint32(str2));
   return 0;
}

回文字符串判断

#include <stdio.h>  
#include <string.h>  
int reverse(char *s)  
{  
    if(strlen(s) == 1 || strlen(s) == 0){
        return 3;
    }
    char t, *p = s,*q = (s + (strlen(s) - 1));
    while (p < q)                       
    {                         
        if(*p++ == *q--)
        {
            continue;
        }
        else
        {
            return 0;  
        }
    }  
    return 1;  
}  
int main()  
{  
     char str[] = "ma3d3ma";
     int bool = reverse(str);
     printf("%d",bool);
     return 0;  
}

字符串包含

给定两个分别由字母组成的字符串 s1 和字符串 s2，如何最快地判断字符串 s2 中所有字母是否都在字符串 s1 里？

#include <stdio.h>
#include <string.h>

int IsContainAllChars(char a[], char b[])
    {
      int hash = 0;
      int lena = strlen(a),lenb = strlen(b);
      for (int i = 0; i < lena; ++i)
      {
        hash |= (1 << (a[i] - 'A'));
      }
      for (int i = 0; i < lenb; ++i)
      {
        if ((hash & (1 << (b[i] - 'A'))) == 0)
        {
          return 0;
        }
      }
      return 1;
}
int main ()
{
   char a[] = "aadwada";
   char b[] = "dw";
   int sign = IsContainAllChars(a,b);
   printf("%d",sign);
   return 0;
}

字符串删除

在s1字符串中删除掉s2字符串中出现的每一个元素。

#include <stdio.h>
#include <string.h>

void del_sub(char *str, char *sub)
{
    char *p;
    int i, j;
    int asc[128] = {0};                  //假设都是ACSII字符
    for (p = sub; *p != ''; p++) {    //先给要删除的字符设置位1
        asc[*p] = 1;
    }  
    for (i = 0, j = 0; i < strlen(str); i++) {  //遍历母串，把不删的字符复制给母串，
        if (!asc[str[i]]) {   //不需要临时空间。
            str[j] = str[i];    //注意遍历时，是strlen而不用减1了，细心点。
            j++;
        }  
    }  
    str[j] = '';      //这里要记住
}


int main ()
{
   char str1[] = "abc123";
   char str2[] = "c3";
   del_sub(str1,str2);
   printf("%s",str1);
   return 0;
}

字符串哈希

原文网址

常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。常用字符串哈希函数有BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。

//SDBMHash
unsigned int SDBMHash(char *str)
{
    unsigned int hash = 0;
 
    while (*str)
    {
        // equivalent to: hash = 65599*hash + (*str++);
        hash = (*str++) + (hash << 6) + (hash << 16) - hash;
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// RS Hash Function
unsigned int RSHash(char *str)
{
    unsigned int b = 378551;
    unsigned int a = 63689;
    unsigned int hash = 0;
 
    while (*str)
    {
        hash = hash * a + (*str++);
        a *= b;
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// JS Hash Function
unsigned int JSHash(char *str)
{
    unsigned int hash = 1315423911;
 
    while (*str)
    {
        hash ^= ((hash << 5) + (*str++) + (hash >> 2));
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// P. J. Weinberger Hash Function
unsigned int PJWHash(char *str)
{
    unsigned int BitsInUnignedInt = (unsigned int)(sizeof(unsigned int) * 8);
    unsigned int ThreeQuarters    = (unsigned int)((BitsInUnignedInt  * 3) / 4);
    unsigned int OneEighth        = (unsigned int)(BitsInUnignedInt / 8);
    unsigned int HighBits         = (unsigned int)(0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    unsigned int hash             = 0;
    unsigned int test             = 0;
 
    while (*str)
    {
        hash = (hash << OneEighth) + (*str++);
        if ((test = hash & HighBits) != 0)
        {
            hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
        }
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// ELF Hash Function
unsigned int ELFHash(char *str)
{
    unsigned int hash = 0;
    unsigned int x    = 0;
 
    while (*str)
    {
        hash = (hash << 4) + (*str++);
        if ((x = hash & 0xF0000000L) != 0)
        {
            hash ^= (x >> 24);
            hash &= ~x;
        }
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;
 
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// DJB Hash Function
unsigned int DJBHash(char *str)
{
    unsigned int hash = 5381;
 
    while (*str)
    {
        hash += (hash << 5) + (*str++);
    }
 
    return (hash & 0x7FFFFFFF);
}
 
// AP Hash Function
unsigned int APHash(char *str)
{
    unsigned int hash = 0;
    int i;
 
    for (i=0; *str; i++)
    {
        if ((i & 1) == 0)
        {
            hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
        }
        else
        {
            hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
        }
    }
 
    return (hash & 0x7FFFFFFF);
}

字符串压缩

#include <stdio.h>
#include <string.h>

int main () {
    //连续字符串压缩
    ////////////////////////////////////////
    char str[20] = "aawwswwccsdddss";
    char str1[20];
    int num1[20] = {0};
    int len;
    len = strlen(str);int i=0,index = 0;
    int sum = 0;
    char str_temp;
    while (i<len){
        str_temp = str[i];
        for(;i<len;i++){
            if (str[i] == str_temp){
                sum ++;
            }
            else{
                str1[index]=str_temp;
                num1[index++] = sum;
                sum = 0;
                break;
            }
        }
    }
    //最后
    str1[index]=str_temp;
    num1[index++] = sum;
    str1[index] = '';
    ///////////////////////////////////
    i = 0;
    int len1 = strlen(str1);
    for(;i<len1;i++)
    printf("%c:%d
",str1[i],num1[i]);
    return 0;
}

十进制数转十六进制数

#include <stdio.h>
#include <math.h> 
//十进制转为十六进制
#define bytesize 4 //十进制数字节大小
#define bitsize (bytesize*8) //十进制数bit位数
#define bit     (bitsize/4) //十六进制位数
int main () {
    int x = 554;
    int i;
    int j;
    int temp;
    short  byte[bit];
    for(i=0;i<bit;i++){
        temp = 0;
        for(j=0;j<bytesize;j++){
            if(x & 1 << (i*bytesize+j)){
                temp += pow(2,j);
            }
        }
        byte[i] = temp;
    }
    for(i=bit-1;i>=0;i--) {
        switch(byte[i]){  
             case 10: printf("A"); break;  
             case 11: printf("B"); break;  
             case 12: printf("C"); break;  
             case 13: printf("D"); break;  
             case 14: printf("E"); break;  
             case 15: printf("F"); break;  
             default: printf("%d",byte[i]); break;  
         }  
    }
        
    return 0;
}

字符串替换

#include <stdio.h>
#include <string.h>

//被替换的字符串str1，需要替换成什么字符串str2，需要替换的字符c    
void replace(char str1[],char str2[],char c){
    if(str1 == NULL || strlen(str1)==0) return;
    //遍历字符串中c的个数
    int i=0;
    int lenstr1 = strlen(str1);  //被替换字符串的长度
    int lenstr2 = strlen(str2); //替换字符串的长度
    short csize = 0; //需要替换字符的个数
    for(;i<lenstr1;i++){
        if(str1[i]==c) csize++;
    }
    //开辟内存
    char strres[lenstr1+csize*lenstr2];
    //替换
    int strresindex=0;
    int j;
    for(i=0;i<lenstr1;i++){
        if(str1[i]==c) {
            for(j=0;j<lenstr2;j++){
                strres[strresindex+j] = str2[j];
            }
            strresindex = strresindex + j;
        }else{
            strres[strresindex] = str1[i];
            strresindex++;
        }
    }
    printf("%s",strres);
    
}    
    
    
int main () {
    char str1[] = "hello wor ld";
    char str2[] = "acs";
    char c = ' ';
    replace(str1,str2,c);    
    return 0;
}

字符串匹配

#include <stdio.h>
#include <string.h>
 
 
//BF暴力匹配字符串
//在一段字符串中匹配一段字符串，如果匹配到，返回下标
int main ()
{
   char str[18] = "li323243543";
   char str1[4] = "3232";
   int  len,len1;
   len = strlen(str);
   len1 = strlen(str1);
   int flag = 1;   //匹配标志
   int startindex = 0; //字符串滑动下标
   int tempstartindex = -1;//字符串下标
   int index = 0; //匹配字符串下标
   while (flag == 1)
   {
       startindex = tempstartindex++; //左移一位
       for(;startindex<len;startindex++)
       {
            //字符串与匹配字符串某个字符匹配
            if(str[startindex] == str1[index])
            {
                index++;
            }
           //字符串与匹配字符串某个字符不匹配
            else
            {
                index = 0;
                break;
            }
           //匹配字符串最后一个字符串匹配成功
           //返回下标字符串
           if(index==len1)
           {
               flag = 0;
               printf("%d
",startindex-len1+1);
               break;
           }
       }
   }
   return 0;
}

第一个只出现一次的字符

#include<stdio.h>
#include<string.h>
#define size 52
int main(void) {
    char str[] = "awdawssvrvdABAFDGD";
    short a[size] = {0};
    int i = 0;
    for(;i<strlen(str);i++){
       if(str[i]>=97)
       a[str[i] - 'a'] +=1;
       if(str[i]<97&&str[i]>=65) 
       a[str[i] - 'A'+26] +=1;   
    }
    for(i=0;i<strlen(str);i++){
       if(str[i]>=97)
        if(a[str[i] - 'a'] == 1){
             printf("%c:%d
",str[i],i); 
             break;
        }
       if(str[i]<97&&str[i]>=65) 
        if(a[str[i] - 'A'] == 1){
             printf("%c:%d
",str[i],i); 
             break;
        }
    }
    return 0;
}