C语言编程题

C语言编程题

　　1)读文件file1.txt的内容(例如)：

　　12

　　34

　　56

　　输出到file2.txt：

　　56

　　34

　　12

　　(逆序)

　　第一题,注意可增长数组的应用.

　　#include

　　#include

　　int main(void)

　　{

　　int MAX = 10;

　　int *a = (int *)malloc(MAX * sizeof(int));

　　int *b;

　　FILE *fp1;

　　FILE *fp2;

　　fp1 = fopen(“a.txt”,”r”);

　　if(fp1 == NULL)

　　{printf(“error1″);

　　exit(-1);

　　}

　　fp2 = fopen(“b.txt”,”w”);

　　if(fp2 == NULL)

　　{printf(“error2″);

　　exit(-1);

　　}

　　int i = 0;

　　int j = 0;

　　while(fscanf(fp1,”%d”,&a[i]) != EOF)

　　{

　　i++;

　　j++;

　　if(i >= MAX)

　　{

　　MAX = 2 * MAX;

　　b = (int*)realloc(a,MAX * sizeof(int));

　　if(b == NULL)

　　{

　　printf(“error3″);

　　exit(-1);

　　}

　　a = b;

　　}

　　}

　　for(;–j >= 0;)

　　fprintf(fp2,”%d\n”,a[j]);

　　fclose(fp1);

　　fclose(fp2);

　　return 0;

　　}

　　可谓是反序的经典例程.

　　void inverse(char *p)

　　{

　　if( *p = = ‘\0′ )

　　return;

　　inverse( p+1 );

　　printf( “%c”, *p );

　　}

　　int main(int argc, char *argv[])

　　{

　　inverse(“abc\0″);

　　return 0;

　　}

　　借签了楼上的“递规反向输出”

　　#include

　　void test(FILE *fread, FILE *fwrite)

　　{

　　char buf[1024] = {0};

　　if (!fgets(buf, sizeof(buf), fread))

　　return;

　　test( fread, fwrite );

　　fputs(buf, fwrite);

　　}

　　int main(int argc, char *argv[])

　　{

　　FILE *fr = NULL;

　　FILE *fw = NULL;

　　fr = fopen(“data”, “rb”);

　　fw = fopen(“dataout”, “wb”);

　　test(fr, fw);

　　fclose(fr);

　　fclose(fw);

　　return 0;

　　}

　　在对齐为4的情况下

　　struct BBB

　　{

　　long num;

　　char *name;

　　short int data;

　　char ha;

　　short ba[5];

　　}*p;

　　p=0×1000000;

　　p+0×200=____;

　　(Ulong)p+0×200=____;

　　(char*)p+0×200=____;

　　希望各位达人给出答案和原因，谢谢拉

　　解答：假设在32位CPU上，

　　sizeof(long) = 4 bytes

　　sizeof(char *) = 4 bytes

　　sizeof(short int) = sizeof(short) = 2 bytes

　　sizeof(char) = 1 bytes

　　由于是4字节对齐，

　　sizeof(struct BBB) = sizeof(*p)

　　= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)

　　p=0×1000000;

　　p+0×200=____;

　　= 0×1000000 + 0×200*24

　　(Ulong)p+0×200=____;

　　= 0×1000000 + 0×200

　　(char*)p+0×200=____;

　　= 0×1000000 + 0×200*4

　　你可以参考一下指针运算的细节

　　2、运用四色定理，为N个局域举行配色，颜色为1、2、3、4四种，另有数组adj[][N]，如adj[i][j]=1则表示i区域与j区域相邻，数组color[N]，如color[i]=1,表示i区域的颜色为1号颜色。

　　四色填充

　　3、用递归算法判断数组a[N]是否为一个递增数组。

　　递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：

　　bool fun( int a[], int n )

　　{

　　if( n= =1 )

　　return true;

　　if( n= =2 )

　　return a[n-1] >= a[n-2];

　　return fun( a,n-1) && ( a[n-1] >= a[n-2] );

　　}

　　4、编写算法，从10亿个浮点数当中，选出其中最大的10000个。

　　用外部排序，在《数据结构》书上有

　　《计算方法导论》在找到第n大的数的算法上加工

　　5、编写一unix程序，防止僵尸进程的出现.

　　3.可怕的题目终于来了

　　象搜索的输入信息是一个字符串，统计300万输入信息中的最热门的前十条，我们每次输入的`一个字符串为不超过255byte,内存使用只有1G,

　　请描述思想，写出算发(c语言)，空间和时间复杂度，

　　4.国内的一些帖吧，如baidu,有几十万个主题，假设每一个主题都有上亿的跟帖子，怎么样设计这个系统速度最好，请描述思想，写出算发(c语言)，空间和时间复杂度，

　　1. 简述一个Linux驱动程序的主要流程与功能。

　　2. 请列举一个软件中时间换空间或者空间换时间的例子。

　　void swap(int a,int b)

　　{

　　int c; c=a;a=b;b=a;

　　}

　　—>空优

　　void swap(int a,int b)

　　{

　　a=a+b;b=a-b;a=a-b;

　　}

　　6. 请问一下程序将输出什么结果?

　　char *RetMenory(void)

　　{

　　char p[] = “hellow world”;

　　return p;

　　}

　　void Test(void)

　　{

　　char *str = NULL;

　　str = RetMemory();

　　printf(str);

　　}

　　RetMenory执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址

　　写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

　　功能：

　　在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如：”abcd12345ed125ss123456789″的首地址传给intputstr后，函数将返回

　　9，outputstr所指的值为123456789

　　int continumax(char *outputstr, char *inputstr)

　　{

　　char *in = inputstr, *out = outputstr, *temp, *final;

　　int count = 0, maxlen = 0;

　　while( *in != ‘\0′ )

　　{

　　if( *in > 47 && *in < 58 )

　　{

　　for(temp = in; *in > 47 && *in < 58 ; in++ )

　　count++;

　　}

　　else

　　in++;

　　if( maxlen < count )

　　{

　　maxlen = count;

　　count = 0;

　　final = temp;

　　}

　　}

　　for(int i = 0; i < maxlen; i++)

　　{

　　*out = *final;

　　out++;

　　final++;

　　}

　　*out = ‘\0′;

　　return maxlen;

　　}

　　不用库函数,用C语言实现将一整型数字转化为字符串

　　方法1：

　　int getlen(char *s){

　　int n;

　　for(n = 0; *s != ‘\0′; s++)

　　n++;

　　return n;

　　}

　　void reverse(char s[])

　　{

　　int c,i,j;

　　for(i = 0,j = getlen(s) – 1; i < j; i++,j–){

　　c = s[i];

　　s[i] = s[j];

　　s[j] = c;

　　}

　　}

　　void itoa(int n,char s[])

　　{

　　int i,sign;

　　if((sign = n) < 0)

　　n = -n;

　　i = 0;

　　do{/*以反序生成数字*/

　　s[i++] = n%10 + ’0′;/*get next number*/

　　}while((n /= 10) > 0);/*delete the number*/

　　if(sign < 0)

　　s[i++] = ‘-’;

　　s[i] = ‘\0′;

　　reverse(s);

　　}

　　方法2:

　　#include

　　using namespace std;

　　void itochar(int num);

　　void itochar(int num)

　　{

　　int i = 0;

　　int j ;

　　char stra[10];

　　char strb[10];

　　while ( num )

　　{

　　stra[i++]=num%10+48;

　　num=num/10;

　　}

　　stra[i] = ‘\0′;

　　for( j=0; j < i; j++)

　　{

　　strb[j] = stra[i-j-1];

　　}

　　strb[j] = ‘\0′;

　　cout< }

　　int main()

　　{

　　int num;

　　cin>>num;

　　itochar(num);

　　return 0;

　　}