c++/c笔试题

 

链表题：一个链表的结点结构

struct Node

{

int data ;

Node *next ;

};

typedef struct Node Node ;

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

我的解答：－）

Node * ReverseList(Node *head) //链表逆序

{

if ( head == NULL)

return head;

 

Node *preNode = NULL ;

Node *curNode = head ;

Node *nxtNode = head->next ;

 

while ( nxtNode != NULL )

{

curNode->next = preNode ;

 

preNode = curNode ;

curNode = nxtNode ;

nxtNode = nxtNode->next ;

}

 

curNode->next = preNode ;

 

return  curNode;

}

(2)已知两个链表head1 和head2 各自有序（升序排列），请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

Node *Merge(Node *head1, Node *head2)

{

Node *head = NULL;

Node *tmp = head;

if (NULL == head1)

return head2;

else if (NULL  == head2)

return head1;

if (head1->data < head2->data)

{

head = head1;

head1 = head1->next;

}

else

{

head = head2;

head2 = head2->next;

}

while (head1 != NULL && head2 != NULL)

{

if (head1->data < head2->data)

{

tmp->next = head1;

tmp = head1;

head1 = head1->next;

}

else

{

tmp->next = head2;

tmp = head2;

head2 = head2->next;

}

}

if (NULL == head1)

{

tmp->next = head2;

}

else if (NULL == head2)

{

tmp->next = head1;

}

}

(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 

Node *Merge(Node *head1, Node *head2)

{

Node *head = NULL;

 

if (NULL == head1)

return head2;

else if(NULL == head2)

return head1;

 

if (head1->data < head2->data)

{

head = head1;

 

head->next = Merge(head1->next, head2);

}

else

{

head = head2;

head->next = Merge(head1, head2->next);

}

 

return head;

}

 

 

42. 写一个函数找出一个整数数组中，第二大的数 （Microsoft）

const int MIN_INTNUM = -(int)0x80000000;

int SecMax(int *array, int size)

{

int secMax = 0;

int firMax = array[0];

 

if (1 == size)

return MIN_INTNUM;

 

for (int i=1; i<size; i++)

{

if( array[i] > firMax )

{

secMax = firMax;

firMax = array[i];

}

else if( array[i] < firMax )

{

if ( array[i] > secMax )

{

secMax = array[i];

}

}

}

 

return secMax;

}

 

 

41. 分析一下这段程序的输出 (Autodesk)

class B

{

public:

B()

{

cout<<"default constructor"<<endl;

}

~B()

{

cout<<"destructed"<<endl;

}

B(int i):data(i) //B(int) works as a converter ( int -> instance of B)

{

cout<<"constructed by parameter " << data <<endl;

}

private:

int data;

};

B Play( B b)

{

return b ;

}

(1) results:

int main(int argc, char* argv[]) // constructed by parameter 5

{  // destructed B(5)形参析构

B t1 = Play(5); B t2 = Play(t1); 　  // destructed t1形参析构

return 0;　　　　　　　　　　　　  // destructed t2　注意顺序！

} // destructed t1

(2) results:

int main(int argc, char* argv[])  // constructed by parameter 5

{  // destructed B(5)形参析构

B t1 = Play(5); B t2 = Play(10); 　  // constructed by parameter 10

return 0;　　　　　　　　　　　　 // destructed B(10)形参析构

} // destructed t2　注意顺序！

// destructed t1

 

 

 

42、另：关于int型的取值范围：

教科书说的是：计算机用“补码”表示负数。 

很多程序员说的是：用二进制数的最高位表示符号，最高位是0，表示正数，最高位是1，表示负数。这种说法本身没错，可是如果没有下文，那么它就是错的。至少它不能解释，为什么字符类型的-1用二进制表示是“1111 1111”(16进制为FF)；而不是我们更能理解的“1000 0001”。（为什么说后者更好理解呢？因为既然说最高位是1时表示负数，那1000 0001不是正好是-1吗？）。 

怎么理解这个问题呢？先得问一句是-1大还是-128大？ 
当然是 -1 大。-1是最大的负整数。以此对应，计算机中无论是字符类型，或者是整数类型，也无论这个整数是几个字节。它都用全1来表示 -1。比如一个字节的数值中：1111 1111表示-1，那么，1111 1111 - 1 是什么呢？和现实中的计算结果完全一致。1111 1111 - 1 = 1111 1110，而1111 1110就是-2。这样一直减下去，当减到只剩最高位用于表示符号的1以外，其它低位全为0时，就是最小的负值了，在一字节中，最小的负值是1000 0000，也就是-128。 

 

43、有N个大小不等的自然数（1--N），请将它们由小到大排序。   
要求程序算法：时间复杂度为O(n)，空间复杂度为O(1)。

 

int cnt = 0;//辅助变量，不是算法组成部分

void sort(int arr[], int n)

{

 int t;  /*临时变量：空间复杂度O(1)*/ 

 //可以证明这个算法每次交换必然将一个数字正确安排到位，而且最多只有N次交换。 

 //具体体现在cnt的值上，所以虽然是二重循环仍然是时间复杂度O(n)

 for (int i = 1; i <= n; i++)

 {

  while(arr[i] != i)

  {

   t = arr[arr[i]];

   arr[arr[i]] = arr[i];

   arr[i] = t;

   ++cnt;

  }

 }

}

 

44、以下程序输出为？

union V

{

struct X{

UCHAR s1:2;

UCHAR s2:3;

UCHAR s3:3;

}x;

 

UCHAR c;

}v;

 

v.c = 100;

 

printf("s3 = %d/n", v.x.s3);

 

result:s3 = 3

分析：100用二进制表示为：b1100100,而位域是从低位到高位排列的，故s1=b00,s2=b001,s3=b11