华为慧通笔试题

C++面试题手机阅读

1 写出程序把一个链表中的接点顺序倒排
　　 typedef struct linknode
　　 {
　　 int data;
　　 struct linknode *next;
　　 }node;
　　 //将一个链表逆置
　　 node *reverse(node *head)
　　 {
　　 node *p,*q,*r;
　　 p=head;
　　 q=p->next;
　　 while(q!=NULL)
　　 {
　　 r=q->next;
　　 q->next=p;
　　 p=q;
　　 q=r;
　　 }
　　 head->next=NULL;
　　 head=p;
　　 return head;
　　 }
　　 2 写出程序删除链表中的所有接点
　　 void del_all(node *head)
　　 {
　　 node *p;
　　 while(head!=NULL)
　　 {
　　 p=head->next;
　　 free(head);
　　 head=p;
　　 }
　　 cout=pbFrom+size || pbFrom>=pbTo+size);//检查两个指针指向的内存是否重叠
　　 while(size–>0)
　　 *pbTo++ == *pbFrom++;
　　 return(pvTo);
　　 }
　　
　　华为面试题：怎么判断链表中是否有环？
　　 bool CircleInList(Link* pHead)
　　 {
　　 if(pHead = = NULL || pHead->next = = NULL)//无节点或只有一个节点并且无自环
　　 return (false);
　　 if(pHead->next = = pHead)//自环
　　 return (true);
　　 Link *pTemp1 = pHead;//step 1
　　 Link *pTemp = pHead->next;//step 2
　　 while(pTemp != pTemp1 && pTemp != NULL && pTemp->next != NULL)
　　 {
　　 pTemp1 = pTemp1->next;
　　 pTemp = pTemp->next->next;
　　 }
　　 if(pTemp = = pTemp1)
　　 return (true);
　　 return (false);
　　 }
　　两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串
　　 void insert(char *s, char *t, int i)
　　 {
　　 memcpy(&s[strlen(t)+i],&s[i],strlen(s)-i);
　　 memcpy(&s[i],t,strlen(t));
　　 s[strlen(s)+strlen(t)]=’′;
　　 }
　　 1。编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
　　 char * search(char *cpSource, char ch)
　　 {
　　 char *cpTemp=NULL, *cpDest=NULL;
　　 int iTemp, iCount=0;
　　 while(*cpSource)
　　 {
　　 if(*cpSource == ch)
　　 {
　　 iTemp = 0;
　　 cpTemp = cpSource;
　　 while(*cpSource == ch)
　　 ++iTemp, ++cpSource;
　　 if(iTemp > iCount)
　　 iCount = iTemp, cpDest = cpTemp;
　　 if(!*cpSource)
　　 break;
　　 }
　　 ++cpSource;
　　 }
　　 return cpDest;
　　 }
　　 2。请编写一个 C 函数，该函数在给定的内存区域搜索给定的字符，并返回该字符所在位置索引值。
　　 int search(char *cpSource, int n, char ch)
　　 {
　　 int i;
　　 for(i=0; inext,并随后删除原next指向的节点。
　　
　　 #include
　　 void foo(int m, int n)
　　 {
　　 printf(“m=%d, n=%d ”, m, n);
　　 }
　　 int main()
　　 {
　　 int b = 3;
　　 foo(b+=3, ++b);
　　 printf(“b=%d ”, b);
　　 return 0;
　　 }
　　输出：m=7,n=4,b=7(VC6.0)
　　这种方式和编译器中得函数调用关系相关即先后入栈顺序。不过不同
　　编译器得处理不同。也是因为C标准中对这种方式说明为未定义，所以
　　各个编译器厂商都有自己得理解，所以最后产生得结果完全不同。
　　因为这样，所以遇见这种函数，我们首先要考虑我们得编译器会如何处理
　　这样得函数，其次看函数得调用方式，不同得调用方式，可能产生不同得
　　结果。最后是看编译器优化。
　　
　　 2.写一函数，实现删除字符串str1中含有的字符串str2.
　　第二个就是利用一个KMP匹配算法找到str2然后删除（用链表实现的话，便捷于数组）
　　
　　 /*雅虎笔试题(字符串操作)
　　给定字符串A和B,输出A和B中的最大公共子串。
　　比如A=”aocdfe” B=”pmcdfa” 则输出”cdf”
　　 */
　　 //Author: azhen
　　 #include
　　 #include
　　 #include
　　 char *commanstring(char shortstring[], char longstring[])
　　 {
　　 int i, j;
　　 char *substring=malloc(256);
　　 if(strstr(longstring, shortstring)!=NULL) //如果……，那么返回shortstring
　　 return shortstring;
　　 for(i=strlen(shortstring)-1;i>0; i–) //否则，开始循环计算
　　 {
　　 for(j=0; jstrlen(str2)) //将短的字符串放前面
　　 comman=commanstring(str2, str1);
　　 else
　　 comman=commanstring(str1, str2);
　　 printf(“the longest comman string is: %s ”, comman);
　　 }
　　
　　 11.写一个函数比较两个字符串str1和str2的大小，若相等返回0，若str1大于
　　 str2返回1，若str1小于str2返回－1
　　 int strcmp ( const char * src,const char * dst)
　　 {
　　 int ret = 0 ;
　　 while( ! (ret = *(unsigned char *)src – *(unsigned char *)dst) && *dst)
　　 {
　　 ++src;
　　 ++dst;
　　 }
　　 if ( ret < 0 )
　　 ret = -1 ;
　　 else if ( ret > 0 )
　　 ret = 1 ;
　　 return( ret );
　　 }
　　
　　 3,求1000！的未尾有几个0（用素数相乘的方法来做，如72=2*2*2*3*3）;
　　求出1->1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3,
　　能被625整除的数的个数n4.
　　 1000!末尾的零的个数=n1+n2+n3+n4;
　　 #include
　　 #define NUM 1000
　　 int find5(int num){
　　 int ret=0;
　　 while(num%5==0){
　　 num/=5;
　　 ret++;
　　 }
　　 return ret;
　　 }
　　 int main(){
　　 int result=0;
　　 int i;
　　 for(i=5;idata == Value)
　　 {
　　 if (pNode->front == NULL)
　　 {
　　 pHeader = pNode->next;
　　 pHeader->front = NULL;
　　 }
　　 else
　　 {
　　 if (pNode->next != NULL)
　　 {
　　 pNode->next->front = pNode->front;
　　 }
　　 pNode->front->next = pNode->next;
　　 }
　　 Node *pNextNode = pNode->next;
　　 delete pNode;
　　 pNode = pNextNode;
　　 bRet = TRUE;
　　 //不要break或return, 删除所有
　　 }
　　 else
　　 {
　　 pNode = pNode->next;
　　 }
　　 }
　　 return bRet;
　　 }
　　 void DE(Node *pHeadA, Node *pHeadB)
　　 {
　　 if (pHeadA == NULL || pHeadB == NULL)
　　 {
　　 return;
　　 }
　　 Node *pNode = pHeadA;
　　 while (pNode != NULL)
　　 {
　　 if (DeteleNode(pHeadB, pNode->data))
　　 {
　　 if (pNode->front == NULL)
　　 {
　　 pHeadA = pNode->next;
　　 pHeadA->front = NULL;
　　 }
　　 else
　　 {
　　 pNode->front->next = pNode->next;
　　 if (pNode->next != NULL)
　　 {
　　 pNode->next->front = pNode->front;
　　 }
　　 }
　　 Node *pNextNode = pNode->next;
　　 delete pNode;
　　 pNode = pNextNode;
　　 }
　　 else
　　 {
　　 pNode = pNode->next;
　　 }
　　 }
　　 }
　　 2. 编程实现：找出两个字符串中最大公共子字符串,如”abccade”,”dgcadde”的最大子串为”cad”
　　 int GetCommon(char *s1, char *s2, char **r1, char **r2)
　　 {
　　 int len1 = strlen(s1);
　　 int len2 = strlen(s2);
　　 int maxlen = 0;
　　 for(int i = 0; i < len1; i++)
　　 {
　　 for(int j = 0; j < len2; j++)
　　 {
　　 if(s1[i] == s2[j])
　　 {
　　 int as = i, bs = j, count = 1;
　　 while(as + 1 < len1 && bs + 1 < len2 && s1[++as] == s2[++bs])
　　 count++;
　　 if(count > maxlen)
　　 {
　　 maxlen = count;
　　 *r1 = s1 + i;
　　 *r2 = s2 + j;
　　 }
　　 }
　　 }
　　 }
　　 3. 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数
　　 char* test3(long num) {
　　 char* buffer = (char*)malloc(11);
　　 buffer[0] = ’0′;
　　 buffer[1] = ‘x’;
　　 buffer[10] = ‘′;
　　 char* temp = buffer + 2;
　　 for (int i=0; i < 8; i++) {
　　 temp[i] = (char)(num28);
　　 temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;
　　 temp[i] = temp[i] < 10 ? temp[i] + 48 : temp[i] + 55;
　　 }
　　 return buffer;
　　 }
　　
　　输入N, 打印 N*N 矩阵
　　比如 N = 3，打印：
　　 1 2 3
　　 8 9 4
　　 7 6 5
　　 N = 4，打印：
　　 1 2 3 4
　　 12 13 14 5
　　 11 16 15 6
　　 10 9 8 7
　　解答：
　　 1 #define N 15
　　 int s[N][N];
　　 void main()
　　 {
　　 int k = 0, i = 0, j = 0;
　　 int a = 1;
　　 for( ; k < (N+1)/2; k++ )
　　 {
　　 while( j < N-k ) s[i][j++] = a++; i++; j–;
　　 while( i < N-k ) s[i++][j] = a++; i–; j–;
　　 while( j > k-1 ) s[i][j--] = a++; i–; j++;
　　 while( i > k ) s[i--][j] = a++; i++; j++;
　　 }
　　 for( i = 0; i < N; i++ )
　　 {
　　 for( j = 0; j < N; j++ )
　　 cout next;
　　 }
　　 tail->next = head->next;
　　 printf(“第%4d个出局的人是：%4d号 ”, i, head->index);
　　 free(head);
　　 head = tail->next;
　　 }
　　 i = head->index;
　　 free(head);
　　 return i;
　　 }
　　 int main()
　　 {
　　 int n, m;
　　 scanf(“%d%d”, &n, &m);
　　 printf(“最后胜利的是%d号！ ”, Josephu(n, m));
　　 system(“pause”);
　　 return 0;
　　 }
　　已知strcpy函数的原型是：
　　 char * strcpy(char * strDest,const char * strSrc);
　　 1.不调用库函数，实现strcpy函数。
　　 2.解释为什么要返回char *。
　　解说：
　　 1.strcpy的实现代码
　　 char * strcpy(char * strDest,const char * strSrc)
　　 {
　　 if ((strDest==NULL)||(strSrc==NULL)) file://[/1]
　　 throw “Invalid argument(s)”; //[2]
　　 char * strDestCopy=strDest; file://[/3]
　　 while ((*strDest++=*strSrc++)!=’′); file://[/4]
　　 return strDestCopy;
　　 }
　　错误的做法：
　　 [1]
　　 (A)不检查指针的有效性，说明答题者不注重代码的健壮性。
　　 (B)检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false三个关键字以提供更安全的条件表达式。
　　 (C)检查指针的有效性时使用((strDest==0)||(strSrc==0))，说明答题者不知道使用常量的好处。直接使用字面常量（如本例中的0）会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。
　　 [2]
　　 (A)return new string(“Invalid argument(s)”);，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。
　　 (B)return 0;，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值（见后面的链式表达式）。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。
　　 [3]
　　 (A)忘记保存原始的strDest值，说明答题者逻辑思维不严密。
　　 [4]
　　 (A)循环写成while (*strDest++=*strSrc++);，同[1](B)。
　　 (B)循环写成while (*strSrc!=’′) *strDest++=*strSrc++;，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上’′。

【华为慧通笔试题】相关文章

1. 华为慧通笔试题

7. 分解成质因数(如435234=251*17*17*3*2，据说是华为笔试题)

8. 杭州龙健科技笔试题.net部分笔试题

9. 阿里巴巴公司DBA笔试题oracle DBA笔试题

10. 华为的Java面试题

本文来源：https://www.mianshiwenti.com/a13178.html