一起来做练习学思路

yundi

目录
1. 1个1G大小的txt文件,每行是一条用户记录(用户名,密码,电话...).编写一个程序,按姓名检索文件，要求越快越好。
2. 两个大数相乘

yundi

1 . 1个1G大小的txt文件,每行是一条用户记录(用户名,密码,电话...).编写一个程序,按姓名检索文件，要求越快越好。

思路：现在电脑一般都４Ｇ内存，不用白不用，把文件全加载到内存，然后在内存中检索。

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <windows.h> //GetTickCount需要
   
5. 
   
6. int main()
   
7. {
   
8.         char path[] = "C:\\Users\\Administrator\\Desktop\\asdfe.txt";
   
9.         FILE * fp = NULL;//文件指针
   
10.         char sbuf[100] = {0};//缓存
    
11.         int star,end;//计时
    
12.         int rowcount = 0;//文件行数
    
13.         char **spp = NULL;//指向指针数组
    
14.         int i;
    
15.         char **tmpp = NULL;//用于遍历指针数组
    
16.         int count ;//统计结果
    
17.         char flag='y';//控制查询循环
    
18.         fp = fopen(path,"r");//打开文件
    
19.         if(fp==NULL)
    
20.         {
    
21.                 return -1;
    
22.         }
    
23.         star = (int)GetTickCount();//开始计时
    
24.         while(!feof(fp))//获取总行数
    
25.         {
    
26.                 fgets(sbuf,100,fp);
    
27.                 rowcount++;
    
28.         }
    
29.         spp = (char **)malloc(sizeof(char*)*rowcount);//分配保存指针数组的内存空间
    
30.         i = rowcount;
    
31.         fseek(fp,0,SEEK_SET);//上一次读到文件尾，这里要回到文件头
    
32. 
    
33.         //将文件全部加载到内存，避免查询时频繁读取硬盘，提高查询效率
    
34.         while(!feof(fp))
    
35.         {
    
36.                 fgets(sbuf,100,fp);//在文件中读取一行，放到缓存
    
37.                 spp[rowcount-i] = (char *)malloc(strlen(sbuf)+1);//申请一段内存，将起始地址保存到指针数组
    
38.                 strcpy(spp[rowcount-i],sbuf);//将缓存复制到申请的内存中
    
39.                 * ((spp[rowcount-i])+strlen(sbuf)) = '\0';//结尾加字符串结束标志
    
40.                 i--;//移动到指针数组的下一位置
    
41.         }
    
42.         end = (int)GetTickCount();
    
43.         printf("载入内存完成！历时%d毫秒\n",end-star);
    
44. 
    
45.         //查询代码
    
46.         while(flag!='n'&&flag!='N')
    
47.         {
    
48.                 printf("\n\n请输入姓名：");
    
49.                 scanf("%s",sbuf);
    
50.                 star = (int)GetTickCount();
    
51.                 count = 0;
    
52.                 for(tmpp = spp;tmpp<spp+rowcount;tmpp++)
    
53.                 {
    
54.                         if(strstr(*tmpp,sbuf))
    
55.                         {
    
56.                                 printf("\n%d行:%s",(tmpp-spp)/sizeof(char*)+1,*tmpp);
    
57.                                 count ++;
    
58.                         }
    
59.                 }
    
60.                 end = (int)GetTickCount();
    
61.                 printf("\n本次查询历时%d毫秒,共有%d条记录",end - star,count);
    
62.                 printf("\n是否继续查询？(y/n)");
    
63.                 scanf("%c",&flag);//用来吃掉输入姓名后的回车键
    
64.                 scanf("%c",&flag);//第二次才接受到'y' or 'n'
    
65.         }
    
66.         //关闭文件！
    
67.         fclose(fp);
    
68.         //释放内存！！！
    
69.         for(tmpp = spp;tmpp<spp+rowcount;tmpp++)
    
70.         {
    
71.                 free(*tmpp);
    
72.         }
    
73.         free(spp);
    
74.         getchar();
    
75. }
    

复制代码

上面是单线程的，如果谁有这样的大文件借我做测试？我就来试试多线程。

yundi

2. 两个大数相乘 。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. //两大数相乘，返回字符串,例如：
   
6. // s1   76789 (i--)
   
7. // s2      98 (j--)
   
8. char * bigmul(const char * s1, const char * s2)
   
9. {
   
10.         int len1 = strlen(s1);//下标 0~len1-1
    
11.         int len2 = strlen(s2);//下标 0~len2-1
    
12.         int len9 = len1 + len2 + 1;//下标 0~len9-2,len9-1
    
13.         int i,j,tmp;
    
14.         char * rel = NULL;
    
15.         char * buf = NULL;
    
16.         //1.申请空间
    
17.         rel = (char *)malloc(sizeof(char)*len9);//保存最终结果,最后一字节是'\0'
    
18.         memset(rel,0,sizeof(char)*len9);
    
19.         buf = (char *)malloc(sizeof(char)*len9);//临时存放s2的某一位与s1相乘结果,最后一字节保存每次相乘的进位
    
20.         //2.计算
    
21.         for(i=len2-1;i>=0;i--)
    
22.         {
    
23.                 memset(buf,0,sizeof(char)*len9);
    
24.                 for(j=len1-1;j>=0;j--) //s2的某一位与s1每位依次相乘
    
25.                 {
    
26.                         tmp = (s1[j]-'0')*(s2[i]-'0') + buf[len9-1];
    
27.                         buf[i+j+1] = tmp % 10;
    
28.                         buf[len9-1] = tmp / 10;
    
29.                 }
    
30.                 buf[i+j+1] = buf[len9-1];
    
31.                 for(j=len9-2;j>=0;j--)
    
32.                 {
    
33.                         rel[j] += buf [j];
    
34.                         if(rel[j]>9)
    
35.                         {
    
36.                                 rel[j] %= 10;
    
37.                                 rel[j-1] += 1;
    
38.                         }
    
39.                 }
    
40.         }
    
41.         free(buf);
    
42.         //3.转为字符
    
43.         for(i=0;i<len9-1;i++)
    
44.         {
    
45.                 rel[i] += '0';
    
46.         }
    
47.         rel[len9-1] = '\0';
    
48. 
    
49.         return rel;
    
50. }
    
51. void main(void)
    
52. {
    
53.         char str1[100] = {0};
    
54.         char str2[100] = {0};
    
55.         char * pstr = NULL;
    
56.         scanf("%s%s",str1,str2);
    
57.         pstr = bigmul(str1,str2);
    
58.         printf("\n%s\n",pstr);
    
59.         free(pstr);
    
60.         system("pause");
    
61. }

复制代码

代码计算过程说明：假设 s1是76789 (i--)，s2是 98 (j--)，i递减表示s1从个位到最高位，j表示s2从个位到最高位。先用s2个位8乘 s1，8*9=72，2存到buf，7存到buf最后一字节；再8*8（s1的十位）=64，64+刚才的进位7=71，1存到buf，又有进位7存到buf最后一字节；直到8*s1最高位，这时buf结果是76789*8=614312。把本轮结果放到rel中，然后进行第二轮，即s2的十位9依次乘s1，结果76789*9=691101存到buf，再把buf累加到rel ……如此循环乘完所有位。

xhbsingle

学习