C/C++笔试题(3)

 

-1.有双向循环链表结点：（华为面试题）

typedef struct node

{

  int date;

  struct node *front,*next;

}_Node;

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两上链表中date值相同的结点删除

参考算法：      
  1.取出A的一个元素d  
  2.收集B中有相同元素d的结点到垃圾箱，并从B里删除  
  3.收集A中有相同元素d的结点到垃圾箱，并从A里删除  
  4.删除垃圾箱中的所有元素  
  5.A链的指针指向下一个  
  6.重复1~5,直到A链循环到头了  
  注意的是第3步，在2步执行后垃圾箱不为空时才执行。  

上述算法还可以做一点点优化：  
  1.加入两个变量cA,   cB,分别记录当前A中和B中的元素个数  
  每次从较长者中取出一个元素来，先从较小者中找起  
  若没有，则不必在较长者中浪费时间了

#include<iostream.h>     ？
  struct   NODE  
  {  
      int   date;  
      NODE   *front,*next;  
  };  

void   redel(NODE   *&ahead,NODE   *&bhead)  
  {  
          int   boy=0;  
          NODE   *pa=ahead,*pb=bhead,*paa,*paaa,*paaaa,*pbb;  
          while(pa->next!=ahead)  
          {  
                  int   boys=pa->date;   //取pa中一个值
                  paaaa=pa;  
                  paa=pa;  
                  pb=bhead;  
                  while(pb->next!=bhead)  
                  {  
                          if(boys==pb->date)   //如果pa,pb中有值相同
                          {        
                                  cout<<endl;  
                                  cout<<"delete   B:"<<paa->date<<"   ";  
                                  if(pb==bhead)  
                                  {  
                                          boy=1;  
                                          pb->front->next=pb->next;  
                                          pb->next->front=pb->front;  
                                          bhead=bhead->next;  
                                          pbb=pb;  
                                          pb=pb->next;  
                                          delete   pbb;  
                                  }          
                                  else  
                                  {  
                                          boy=1;  
                                          pb->front->next=pb->next;  
                                          pb->next->front=pb->front;  
                                          pbb=pb;  
                                          pb=pb->next;  
                                          delete   pbb;  
                                  }  
                          }  
                          else  
                                  pb=pb->next;                
                  }  
                  while(paa->next!=ahead   &&   boy==1)  
                  {          
                          if(paa->date==boys)  
                          {        
                                  cout<<"delete   A:"<<paa->date<<"   ";  
                                  if(paa==pa)  
                                  {  
                                          pa=pa->next;  
                                          ahead=pa;  
                                          paa->front->next=paa->next;  
                                          paa->next->front=paa->front;  
                                          paaa=paa;  
                                          paa=paa->next;  
                                          delete   paaa;  
                                  }          
                                  else  
                                  {  
                                          paa->front->next=paa->next;  
                                          paa->next->front=paa->front;  
                                          paaa=paa;  
                                          paa=paa->next;  
                                          delete   paaa;  
                                  }          
                          }  

   else  
                          {  
                                  paa=paa->next;  
                          }          
                  }  
                  boy=0;  
                  if(paaaa==pa)  
                          pa=pa->next;  
          }  
          cout<<endl;                      
  }

int   main()  
  {  
          NODE   *A,*pHeadA,*B,*pHeadB;  
          A=new   NODE;  
          B=new   NODE;  
          pHeadA=A;  
          pHeadB=B;  
          for(int   i=1;i<21;++i)             //生成链表A,并赋初值!  
          {  
                  A->date=i;  
                  A->next=new   NODE;  
                  A->next->front=A;  
                  A=A->next;  
          }  
          A=A->front;  
          delete   A->next;  
          A->next=pHeadA;  
          pHeadA->front=A;  
           
          for(int   i=1;i<33;i+=2)         //生成链表B,并赋初值!  
          {  
                  B->date=i;  
                  B->next=new   NODE;  
                  B->next->front=B;  
                  B=B->next;  
          }  
          B=B->front;  
          delete   B->next;  
          B->next=pHeadB;  
          pHeadB->front=B;  
           
          redel(pHeadA,pHeadB);         //调用函数删除相同结点!  
  }  

 

0.

char * GetStr()

{

char *tmp;

tmp = "123"

return tmp;

}

 

void main()

{

printf("%s", GetStr());

}

会输出123吗？123创建在堆上还是栈上呢？123的空间是什么时候释放的？

参考："123"  是常量字符串，存储在全局变量区，和静态变量一起。即不在堆，也不在栈   在程序结束时自动释放   

 

1.1）字符指针、浮点数指针、以及函数指针这三种类型的变量哪个占用的内存最大？为什么？

答案：指针变量也占用内存单元，而且所有指针变量占用内存单元的数量都是相同的。就是说，不管是指向何种对象的指针变量，它们占用内存的字节数都是一样的，并且要足够把程序中所能用到的最大地址表示出来（通常是一个机器字长）。

 

2）类ClassB从ClassA派生，那么ClassA *a = new ClassB(…); 试问该表达是否合法？为什

么？

答案：派生类的指针指向基类的对象是错误的，不能通过编译的； 基类的指针可以指向派生类的对象，调用派生类的函数

鸡是动物，没错。（ 动物的指针 指向 鸡的实例）

鸡可以执行所有动物都具有的方法，例如 “死亡”

反过来，动物一定是鸡吗？（鸡的指针 指向 动物或者动物的某个派生类的实例）

动物都能执行鸡的某个方法吗？比如说 “下蛋”？

 

3）如果ClassA中定义并实现虚函数int func(void)，ClassB中也实现该函数，那么上述变量

a->func()将调用哪个类里面的函数？如果int func(void)不是虚函数，情况又如何？为什

么？

答案：第一问调用的是B的。第二问调用A的。

虚函数的一个典型应用，虚函数只能借助于指针或者引用来达到多态的效果

如果没有定义成虚函数：------

class A{
public:
void print(){ cout<<”This is A”<<endl;}
};

class B:public A{
public:
void print(){ cout<<”This is B”<<endl;}
};

int main(){   //为了在以后便于区分，我这段main()代码叫做main1
A a;  B b;
A* p1=&a;
A* p2=&b;
p1->print();
p2->print();
}

结果是两个This is A

如果定义成虚函数：---------

class A{
public:
virtual void print(){ cout<<”This is A”<<endl;}  //现在成了虚函数了
};

class B:public A{
public:
void print(){ cout<<”This is B”<<endl;}  //这里不需要在前面加上关键字virtual，只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数
};

再运行main输出的结果就是This is A和This is B

 

测试：

4）char **p, a[16][8];  问：p=a是否会导致程序在以后出现问题？为什么？

参考: 这个不会导致出现问题，但是要注意p的使用，如a[1][2] 等价的为 *(*(p+1)+2)而不是*(p+11),

会的，这样会出现编译错误  正确的是：char a[5][5]; char (*p)[5]; p=a;

如下所述的if else和switch语句哪个的效率高？为什么？

 

5）在同一个进程中，一个模块是否可以通过指针操作破坏其它模块的内存，为什么？（华为）

 

6）应用程序在运行时的内存包括代码区和数据区，其中数据区又包括哪些部分？

参考：对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。 

 

2.Assignment 2: Picture Processing

 

Use C++, Java, or similar languages or/and any middleware such as EJB and J2EE

 to process a  picture with a high resolution (3 Mega Pixels for example). Use

 some methodologies to degrade  the resolution of the picture to make it quick

er for browsing. Then divide the degraded  picture into 9 sectors equally. Cli

ck any of the 9 sectors will result a detailed picture for  this sector with t

he same resolution as that of the original picture. This assignment is  design

ed for you to demonstrate your ability to handle pictures.

 

3.用<<,>>,|,&实现一个WORD(2个字节)的高低位交换!!

int  main() 

{ 

unsigned  short  a  =  0xABCD; 

unsigned  short  b  ; 

unsigned  short  c  ,d; 

b  =  (a  <<  8)&0xff00;   

c  =  (a  >>  8)&0x00ff; 

d  =  b  |  c; 

printf("/n%x",b); 

printf("/n%x",c); 

printf("/n%x",d); 

return  0; 

} 

结果是  CDAB   

2俩个字节是16位  前八位为高位  后八位为低位  然后结合

 

4.要开辟P1,P2,P3,P4内存来做缓冲,大小自定,但这四个缓冲的大小要一样,并且是连续的

 

5.有一浮点型数组A,用C语言写一函数实现对浮点数组A进行降序排序,并输出结果,要求要

以数组A作为函数的入口.(建议用冒泡排序法)

void   BubbleSort(double   arr[],   int   n)  
        {  int   i，j；  
            int   exchange   =   1；   //交换标志  
            for(i=1;i<n;i++){   //最多做n-1趟排序  
                exchange=0；   //本趟排序开始前，交换标志应为假  
                for(j=n-1;j>=i；j--)   //对当前无序区R[i..n]自下向上扫描  
                  if(arr[j+1]   >   arr[j]){//交换记录  
                      arr[0]=arr[j+1]；   //R[0]不是哨兵，仅做暂存单元  
                      arr[j+1]=arr[j]；  
                      arr[j]=arr[0]；  
                      exchange=1；   //发生了交换，故将交换标志置为真  
                    }  
                if(!exchange)   //本趟排序未发生交换，提前终止算法  
                            return；  
            }   //endfor(外循环)  
          }

 

6.找错：

#include <string.h>

#include <stdio.h>

class Base

{ private:

char * name;

public:

Base(char * className)

{

name = new char[strlen(className)];

strcpy(name, className);

}

~Base()

{delete name;}

char * copyName()

{

char newname [256];

strcpy(newname, name);

return newname;

}

char * getName()

{return name;}

static void print(Base base)

{printf("name: %s/n" , base.name);}

};

class Subclass : public Base

{

public:

Subclass(char * className) : Base(className)

{ }

};

int main()

{

Base * pBase = new Subclass("test");

Base::print(*pBase);

printf("name: %s/n", pBase->getName());

printf("new name: %s/n", pBase->copyName());

return 0;

}

 

7.编写一个函数，函数接收一个字符串,是由十六进制数组成的一组字符串,函数的功能是

把接到的这组字符串转换成十进制数字.并将十进制数字返回.

答案：

BOOL   HexToDec(   LPCTSTR   shex,int&   idec   )  
  {  
      int   i,mid;  
      int   len   =   lstrlen(   shex   );  
      if(   len>8   )  
          return   FALSE;  
      mid   =   0;   idec   =   0;  
      for(   i=0;i<len;i++   )  
      {  
          if(   shex[i]>='0'&&shex[i]<='9'   )  
              mid   =   shex[i]-'0';  

 else   if(   shex[i]>='a'&&shex[i]<='f'   )  
              mid   =   shex[i]   -'a'   +10;  
          else   if(   shex[i]>='A'&&shex[i]<='F'   )  
              mid   =   shex[i]   -'A'   +10;  
          else  
              return   FALSE;  
   
          mid   <<=   ((len-i-1)<<2);   // 移位表示变为2的n次方倍

          idec   =idc+mid;  
   
      }  
      return   TRUE;  
  }  

 

8.编写一个函数将一条字符串分成两部分，将前半部分按ASCII码升序排序，后半部分不

变，（如果字符串是奇数则中间的字符不变，）最后再将前后两部分交换，然后将该字符

串输出，

测试字符串“ADZDDJKJFIEJHGI”

 

9.找错

Void test1()

{   char string[10];

    char* str1="0123456789";

strcpy(string, str1);

}

Void test2()

{ char string[10], str1[10];

for(I=0; I<10;I++)

{str1[i] ='a';}

strcpy(string, str1);

}

Void test3(char* str1)

{  char string[10];

   if(strlen(str1)<=10)

{ strcpy(string, str1);}

}

 

10.    找错

#define MAX_SRM 256

DSN get_SRM_no()

{  static int SRM_no;

   int I;

   for(I=0;I{

SRM_no %= MAX_SRM;

if(MY_SRM.state==IDLE)

{

    break;

}

}

if(I>=MAX_SRM)

return (NULL_SRM);

else

return SRM_no;

}