数据结构[二]

 

==============================================

 

字符串处理

 

strlen()用来计算字符的长度，并不包括结束字符'/0',空字符长度为0

  1 #include <stdio.h>

  2 

  3 int Strlen(char string[])

  4 {

  5     int len,i;

  6     for(i=0;string[i] != '/0';)

  7             i++;

  8     return i;

  9 }

 10 int main()

 11 {

 12     int len;

 13     char string[50] = "111111111111111111111111111111234567890";

 14     len = Strlen(string);

 15     printf("len = %d/n",len);

 16     return 0;

 17 }

 

strcpy(char str1[],char str2[])用来拷贝字符串，把str2每个字符都拷贝到str1中，直到结束符'/0'

1 #include <stdio.h>

  2 #include <string.h>

  3 char *Strcpy(char *str2,char *str1)

  4 {

  5     int i,len;

  6     /*

  7     for(i=0;str1[i] != '/0';i++)

  8     {

  9             str2[i] = str1[i];

 10     }

 11     str2[i] = '/0';

 12     */

 13     for(i=0;i<10;i++)

 14     {

 15         if(str1[i] != '/0')

 16                 str2[i] = str1[i];

 17     }

 18     str2[i] = '/0';

 19     return str2;

 20 }

 21 int main()

 22 {

 23     char str1[] = "1234567890";

 24     char str2[10];

 25     Strcpy(str2,str1);

 26     printf("%s/n",str2);

 27 

 28 }

 

strcat(char str1[],char str2[])字符串连接，把str1结束符去掉，然后把str2连接到str1处，组成新的字符串。

  1 #include <stdio.h>

  2 

  3 char *Strcat(char *str1,char *str2)

  4 {

  5         char *tmp = str1;

  6         while(*tmp)

  7                 tmp++;

  8         while((*tmp++ = *str2++) != '/0')

  9                 ;

 10         return str1;

 11 }

 12 int main()

 13 {

 14         char str1[100] ;;

 15         char str2[50] ;

 16         printf("Input char:/n");

 17         scanf("%s",str1);

 18         scanf("%s",str2);

 19         Strcat(str1,str2);

 20         printf("%s/n",str1);

 21 }

~                          

strrep(char *str1,char *str2,int num)从str1找到num的位置,用str2字符来替换从这个位置开始后面的内容

  #include <stdio.h>

 

  3 char *Strrep(char *str1,char *str2,int num)

  4 {

  5         int i,j=0;

  6     //  num--;

  7         for(i=num;str1[i]!='/0';i++)

  8     //          for(j=0;str2[j]!='/0';j++)

  9                 if(str2[j] != '/0')

 10                 {

 11                     str1[i] = str2[j];

 12                     j++;

 13                 }

 14                 else

 15                         break;

 16         return str1;

 17 

 18 

 19 }

 20 int main()

 21 {

 22         char str1[100] ;;

 23         char str2[50] ;

 24         int num;

 25         printf("Input char:/n");

 26         scanf("%s",str1);

 27         scanf("%s",str2);

 28         scanf("%d",&num);

 29         Strrep(str1,str2,num);

 30         printf("%s/n",str1);

 31 }

 

十进制转十六进制

输入一个数，除以16所得的商如>16话继续除，直到商<16，然后取商和它余数

1 #include <stdio.h>

  2 

  3 void shito16_(int num_)

  4 {

  5     int num;

  6     int data;

  7     if(num_/16)

  8         shito16_(num_/16);

  9     num = num_%16;

 10 

 11     if(num>=0&&num<=9)

 12     {

 13             printf("%d/n",num);

 14     }

 15     else

 16     {

 17         switch(num)

 18         {

 19             case 10:printf("%c/n",'A');break;

 20             case 11:printf("%c/n",'B');break;

 21             case 12:printf("%c/n",'C');break;

 22             case 13:printf("%c/n",'D');break;

 23             case 14:printf("%c/n",'E');break;

 24             case 15:printf("%c/n",'F');break;

 25         }

 26     }

 27 }

 

strdel(char str[],int top,int len)把从top位置开始处长度为len的子串删除

找到删除的子串末端str[top+len],把这个位置开始后面字符移动top开始的位置,反复此操作

char *strlen(char str[],in totp,int len)

{

int i;

for(i=top+len,str[i]='/0';i++)

str[i-len]=str[i];

str[i-len] = '/0';

return str;

}

 

substr(char str[],int top,int len)提取从top开始处长度len的str子串

 1 #include <stdio.h>

  2 

  3 char *Substr(char str[],int top,int len)

  4 {

  5     int i,j=0;

  6     top--;

  7     for(i=top;i<top+len;i++)

  8             str[j++]=str[i];

  9     str[j] = '/0';

 10     return str;

 11 }

 12 int main()

 13 {

 14     int i,j;

 15     char str[]="hellowrold";

 16 

 17     printf("%s/n",Substr( str,3,5));

 18 

 19 }

~      

strlen_sub(char str1[],char str2[])，str1,str2最长公共子串

 

 

  1 #include<stdio.h>

  2 #include<stdlib.h>

  3 #include<string.h>

  4 

  5 char *commanstring(char shortstring[], char longstring[])

  6 {

  7         int i, j;

  8         char *substring=malloc(256);

  9         if(strstr(longstring, shortstring)!=NULL)              //如果……，那么返回shortstring

 10                 return shortstring;

 11 

 12                 for(i=strlen(shortstring)-1;i>0;i-- )                 //否则，开始循环计算

 13                 {

 14                             for(j=0; j<=strlen(shortstring)-i; j++){

 15                                         memcpy(substring, &shortstring[j], i);

 16                                             substring[i]='/0';

 17                                               if(strstr(longstring, substring)!=NULL)

 18                                                         return substring;

 19                             }

 20                 }

 21                 return NULL;

 22 }

 23 

 24 main()

 25 {

 26         char *str1=malloc(256);

 27         char *str2=malloc(256);

 28         char *comman=NULL;

 29         gets(str1);

 30         gets(str2);

 31         if(strlen(str1)>strlen(str2))                         //将短的字符串放前面

 32             comman=commanstring(str2, str1);

 33         else

 34             comman=commanstring(str1, str2);

 35             printf("%s",comman);

 

str_daoxu()，首获取字符串长度，再把长度折半，少于半长度循环，把第一字符与最后一个字符交换，再把第二个与倒数

 

第二个交换.....

 

int main()

{

char str[]="hello,world";

int len = strlen(str);

int i;

char c;

 

for(i=0;i<len/2;i++)

{

c = str[i];

str[i] = str[len-1-i];

str[len-1-i] = c;

}

printf("%s",str);

}

 

LoopMove(char str,int i;)循环右移i个，获取str总长度，如i>0,得到剩余长度个数

 

LoopMove(char str,int i;)

{

while(scanf("%d%s",&i,str) != NULL)

 {

int len;

char *pn;

 

len = strlen(str);

if(i>=0)

len = len - n%len

pn  = str + len;

pirntf("%s",pn)   //先打印str+len后面的字符

*pn  = '/0';

pirntf("%s",str);  //再打印str后面的字符

pn = NULL;

  }

}

 

 

=====================================================

内部排序法--交换排序

冒泡排序法,若10个数排序，两两比较，若左边大于右边就互相交换，小的放前面,大者放后面，循环地这样10次。

   #include <stdio.h>

  2 

  3 void sort(int str[],int num)

  4 {

  5     int i,j;

  6     int tmp;

  7     for(i=num;i>0;i--)

  8     {

  9             for(j=0;j<i-1;j++)

 10                 if(str[j]>str[j+1])

 11                 {

 12                         tmp = str[j];

 13                         str[j] = str[j+1];

 14                         str[j+1] = tmp;

 15                 }

 16     }

 17     for(i=0;i<num;i++)

 18             printf("%d/n",str[i]);

 19 }

 20 int main()

 21 {

 22     int str[]={37,96,8,54,32,18};

 23     int num=6;

 24     sort(str,num);

 25 }   

~        

 

快速排序

设置一个标识数povit，把i指向左边开始处，从左往右搜索比poivt大的值，把j指右边开始处，从右往左搜索比poivt小的

 

值，若i<j，则i,j当前指向的值交换（也就是小的放在左边，大的放在右边），若i>j，则把j当前指向的值与poivt交换，

 

因为povit比str[j]要大。这时j指向的当为中间值，把数组分割成两半，递归调用排序左半边值和右半边值。

 

 

quicksort(int list[] ,int left,int right,int index)

{

int i,j,k;

int pivot,tmp;

i =left;j = right+1;

pivot = list[left];

if(i<j)

{

do{

do{

i++;

}while(list[i]<=pivot&&i<=right);

do{

j++;

}while(list[i]>=pivot&&i>=right);

 

    if(i<j)

    {

tmp=list[i];

list[i] = list[j];

list[j] = tmp;

     }

   }while(i<j)

  tmp=list[left];

  list[left]= list[j];

  list[j] = tmp;

quicksort(list ,left,j-1,index);

quicksort(list ,j+1,right,index)

}

}

 

内部排序法

是从欲排序的数据中，选出第一个数为预最小的，然后与后面的数比较，若比这个数比预最小数还小，则把该数设置为最小

 

数.最后把最数与第一个数交换，再找次小数。

 

1.选择排序

  1 #include <stdio.h>

  2 #include <string.h>

  3 void selectsort(int str[],int num)

  4 {

  5     int i,j,k,min,a;

  6     int tmp;

  7     for(i=0;i<num-1;i++)

  8     {

  9         min=32767;

 10         k = 0;

 11         for(j=i;j<num;j++)

 12         {

 13             if(str[j]<min)

 14             {

 15                 min=str[j];

 16                 k = j;

 17             }

 18         }

 19                 tmp= str[i];      //把第一个数与找出来的最小数交换

 20                 str[i] = str[k];

 21                 str[k] = tmp;

 22     }

 23     for(a=0;a<num;a++)

 24             printf("%d/n",str[a]);

 25 

 26 }

 27 int main()

 28 {

 29     int str[]={12,15,54,67,98,9,56,3,77,66};

 30     int num = 10;

 31     selectsort(str,num);

 32 }  

 

==============================================