微软十五道面试题( 自己的实现,求更有解~~~~ O(∩_∩)O~ )

原创 2012年03月21日 06:56:02

1、有一个整数数组,请求出两两之差绝对值最小的值,
记住,只要得出最小值即可,不需要求出是哪两个数。

int num =MAXNUM;        //! 可否有优化?

int temp;

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

{

for ( int j = i + 1 ; j < maxsize; j++)

{

  temp = fabs( a[i]  a[j]  ;

  num =  num> temp  temp :num ;

}

}

我们可以看一下上面的复杂度:应该是:1+2+…+(maxsize-1),所以是O(n^2 );

但是if我们先排序一下(优化算法可以用STL的nth_element处理),然后只要遍历一次,两两比较就可以了!

CODE:

int num = MAXNUM;

int temp;

nth_element( a, a + mid, a + maxsize);   //!sort…

for( int  i = 0; i < maxsize- 1; i++ )

{

      temp = abs( a[i] – a[i+1] );

      num =  num > temp ? temp ,num;

}

                             

可以知道:nth_element的时间复杂度是<O(n^2)的,后面的for也就是O(n),所以整体放入复杂度就是接近O(n),所以效率更高!

 

2、写一个函数,检查字符是否是整数,如果是,返回其整数值。
(或者:怎样只用4行代码编写出一个从字符串到长整形的函数?)

(1).

#include <stdio.h>

#include <math.h>

#include <string.h>

int main()

{

      char str[] = "34567";

      int strSize = strlen( str );

      long num = 0;

      for(  int i 0;  strSize;  i++)

      {

             if( ! ( str[i] >= '0' && str[i] <='9'  ) )

             {

                    printf( "no\n" );

                    goto end;

             }

             else

             {

                    num += long( pow( 10,  strSize - i - 1 )*  int( str[i] - '0' ));

             }

      }

      printf("num = %ld\n", num);

end:

      return 0;

}

( 2 ).

long  strToLong( char * str )

{

for( int i = 0; i < strlen( str);  i++ )

num += ( long )( pow( strlen( str ) – 1 - i ) * ( int )(str[i] – ‘0’ ) );

return num;

}

3、给出一个函数来输出一个字符串的所有排列。( 全排列 )

#include <stdio.h>

#include <string.h>

void swapElem( char * c1, char * c2)    //! 交换两个元素

{

      char temp;

      temp  = *c1;

      *c1   = *c2;

      *c2   = temp;

}

void permSort( char str[], int maxsize, int startIndex)   //! 全排列

{

      if ( startIndex == maxsize - 1)    //!最后只剩下一个元素的遍历咯,就输出吧!

      {

             puts( str );

             return;

      }

      for ( int i = startIndex; i < maxsize; i++)          //!

      {

             swapElem( &str[i], &str[startIndex]);          

  //! 注意此处交换后面的几个元素,需要用递归

             permSort( str, maxsize, startIndex + 1 );

             swapElem( &str[startIndex], &str[i]);            //! 记得要交换回来!!!

               

}

int main()

{

      char str[] = "12345";

      int maxsize = strlen( str );

      permSort( str, maxsize, 0 );

      return 0;

}

 

4、请编写实现malloc()内存分配函数功能一样的代码。
给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

 //! 这个我真不会!求高人!!!

 //!???????????????????????????????????????????????????????????????????

 

5、怎样编写一个程序,把一个有序整数数组放到二叉树中?( 采用递归方法 )

pTree  t;   //!给一个全局的tree来先

void   putInBinTree( inta[], int low, int high, pTree t )

{

      if( low >= high )

{

  t->value = a[low];

  t->lChild = NULL;

  t->rChild = NULL;

  return;

}

int  mid = ( low + high ) / 2;

t->value = a[mid];

if( mid – 1 >= low )

{

putInBinTree( a, low, mid – 1, t->lChild);

}

if( mid + 1 <= high )

{

putInBinTree( a, mid + 1, high , t->rChild);

 }

}

 

6、怎样从顶部开始逐层打印二叉树结点数据?请编程。  (就是层次遍历而已、、、 )

//!  ( tail – head + MaxNum ) % MaxNum== 实际元素个数

treeNode queue[100];   //! 节点队列

int head = 0;

int tail = 1;

queue[tail++] = rootTree;  //! 先把头放进去

while( !queue.isEmpty())

{

      printf(“%d”, queue[++head]->value);

      if(queue[head]->lChild != NULL )

{

             queue[tail++] = queue[head]->lChild;

      }

      if(queue[head]->rChild != NULL )

{

queue[tail++] = queue[head]->rChild;

}

}

 

7、怎样把一个链表掉个顺序(也就是反序,注意链表的边界条件并考虑空链表)?

当然对于此题来说:我的思路是我们需要一个栈空间来做temp,然后出栈就倒置了,呵呵~

例如现在有一个链表pLinkList   ls;   //! 前提是有头链表

void  reverseLinkList( pLinkList ls)

{

      pLinkList  head = NULL;

linkList  tempStack;

      int       top = -1;

      head = ls->next;

      while( head != NULL )

{

  tempStack[++top] = head;

  head = head->next;

}

ls->next = head;

While( top >= 0 )

{

  head = tempStack[top--];

  head->next = NULL;

  head = head->next;

}

}

 

>>>当然我现在又想到另一种方法,就是不需要额外的栈空间的,利用链表插入法:遍历每个元素都往头head后面插入,那么完成后就是倒置的了,呵呵~~~

pLinkList newHead = NULL;

pLinkList head = ls->next;

while( head != NULL )

{

      newHead->next = head;

      head = head->next;

}

//!那么最后 newHead 就是倒置的链表咯

 

8、请编写能直接实现int atoi(const char * pstr)函数功能的代码。

 

int  atoi( char * pstr )

{

      const char * strTemp = pstr;

      assert(  strTemp != NULL );   //!先要断言不是NULL

      int num = 0;

      int size = strlen ( strTemp );

      int i= 0;

      while( strTemp[i] )

      {

             assert( strTemp[i] >= '0' &&  strTemp[i]<= '9' ); 

 //! 断言是数字字符

             num += (int)( pow( 10, size - i - 1 ) * ( strTemp[i] - '0' ));

             i++;

      }

      return num;

}

9、编程实现两个正整数的除法

编程实现两个正整数的除法,当然不能用除法操作符。
//! 这一题有问题!希望有好解!

unsigned int div (unsigned int a, unsigned int b)
{
   int i;
   unsigned int m = 0;
   for (i = 1; i <= 32; i++)
   {
           m = (m << 1) | (a >> 31);
           a = a << 1;
           if (m >= b)
           {
               m = m - b;
               a = a + 1;
           }
   }
 
   return a;
}

 

10、在排序数组中,找出给定数字的出现次数
比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。

//! 我的思路是当然先要二分法找到此数在处理(我们知道在排序好的查找元素二分法最快 )

int  getCount( intarray[],  int num, int size )

{

      int low = 0;

      int high = size - 1;

      int count = 0;

      int mid;

      while ( low <= high )

      {

             mid =  ( low + high ) / 2;

 

             if( array[mid]  > num )

             {

                    high = mid - 1;

             }

             else if(array[mid]  < num )

             {

                    low = mid + 1;

             }

             else

             {

                    break;   //! mid is myfood!

             }

      }

      low  = mid;

      high = mid + 1;

      while( low >=0 && array[low] == num )

      {

             count++;

             low--;

      }

      while( high <= (size - 1) && array[high] == num )

      {

             count++;

             high++;

      }

      return count;

}

 

 

11、平面上N个点,每两个点都确定一条直线,
求出斜率最大的那条直线所通过的两个点(斜率不存在的情况不考虑)。时间效率越高越好。

斜率公式是:k = (y2 – y1) / (x2 – x1);

我的思路是:先按照X将所有的point进行排序,然后对他们进行遍历,由于数学上有讲过-àif排序为A,B,C那么AB和BC中必然有一个比AC斜率大,一个比他小,所以需要进行计算,然后遍历推进直到点结束,最后找到最大!不知道还有么有更好的办法(此办法不能保证是百分百正确,只是自己的想法而已、、、 )

首先我们假设已经有了point的结构体:

typedef   structpoint

{

      int  s_x;

          int  s_y;s

}point;

point  allPoint[N];   //! 有N个点

void  getMaxSlopePoint(point  allPoint[]  )

{

      point A, B, C;

      double maxSlope = 0;

      point p1, p2;

      //! 此处的排序就不说了

      for(  i = 0;  i <N - 2;  i++   //! 由于下面i+2 所以遍历到N-2就OK了!!!

{

  A = allPoint[i];

  B = allPoint[i+1];

  C = allPoint[i+2];

  double  Kab = ( A.y – B.y) / ( A.x – B.x );

  double  Kbc = ( B.y – C.y) / ( B.x – C.x );

  if( Kab > Kbc )
             {

        maxSlope = Kab;

        p1 = a;

        p2 = b;

}

else

{

        maxSlope = Kbc;

        p1 = b;

        p2 = c;

}

}

}

 

 

12、一个整数数列,元素取值可能是0~65535中的任意一个数,相同数值不会重复出现。0是例外,可以反复出现。
请设计一个算法,当你从该数列中随意选取5个数值,判断这5个数值是否连续相邻。
注意:
- 5个数值允许是乱序的。比如: 8 7 5 0 6
- 0可以通配任意数值。比如:8 7 5 0 6 中的0可以通配成9或者4
- 0可以多次出现。
- 复杂度如果是O(n2)则不得分。

>>>我们将题目简化为:有一个5元素的数组,比较是否相邻(当然要满足上面的条件! )

CODE:

基本思想:先将它们从小到大排序,我们只对于非0的元素进行判断,因为0可以代表任何元素!那么返回false的条件是:有重复的数;非0元素之间的最大差值已经超过4了!然后就都是可以的!时间复杂度是O( nlog(n) )

操作方法是:把他们正确的放进数组b中,if不满足上面条件的是放不进去得!相当于第一个非0元素是一个标准,然后后面的非0元素的放入是值想减放到指定的空间,if空间不满足,那么就是返回false!

bool judgeFun( int num[], int size)     //! 注意这里的num是已经选出的5个数

{

      int b[5] = { 0, 0, 0, 0, 0};      //! five space is ok!

      int i = 0;

      nth_element( num, num[(int)size/2],num[size-1] ); //! STL sort

 //! sort first:时间复杂度是:O(nlog(n) )

      b[0] =num[i];                  //! the first num

      i++;

      while( i < size)                //! 复杂度是O( n )

      {

             if ( num[i] - b[0] > 4)     //! 说明不在相邻的5的范围内,false

             {

                    return false;

             }

 

             if ( b[num[i] - b[0]] != 0 ) 

//! 说明此处已经有了元素进入,那么也就是说有重复元素,所以不可能是相邻的呗!

             {

                    return false;

             }

             b[num[i] - b[0]] = num[i];

             i++;

      }

      return true;

}

 

13、设计一个算法,找出二叉树上任意两个结点的最近共同父结点。
复杂度如果是O(n2)则不得分。

我的思路:

      >>>If说:数据结构是我们自己可以定义的话,那么我觉得子女可以有一个域保存parent,那么我们就可以分别先求出两个子节点的深度,较深的先向上走直到与浅的一样,再共同向上,肯定能找到,这样复杂度就是O(n),但是貌似这一题没有给我们这么优势的条件,所以怎么办呢?????

      >>>然后还有一个想法就是说:从根节点开始,向下遍历,直到找到两个点,记录标号路径,然后比较就可以得到答案,时间复杂度是O(n),但是需要空间的支持!

      >>>其实这一题就是LCA问题             ( 最近公共祖先问题lowestcommon ancestor),所谓的思想就是说:使用后序遍历,一旦察觉到两个子节点在A的二叉上,那么这个A就是最小祖先!有一个特殊情况就是说:if两个子节点在同一个叉上,也就是说一个可能是另一个的父亲,那么只要找到爷爷就OK呵呵!O(∩_∩)O~ 至于为什么要用后序遍历,那么我们知道,后序遍历parent是最后出来的,那么一旦读到parent的时候就可以判断是不是已经满足两个孩子的条件咯!

CODE略!

 

14、一棵排序二叉树,令 f=(最大值+最小值)/2,
设计一个算法,找出距离f值最近、大于f值的结点。
复杂度如果是O(n2)则不得分。

//!     首先我们需要找到f的值,其实这个还是很好求的:从root开始,遍历左孩子直到NULL,min找到,还是从root开始遍历右孩子直到NULL,找到max;那么f我们现在求到了!

//!     然后再从root开始比较,if比此时的节点小那么就是记录此点,然后与左孩子比较,if比他大,那么往右孩子找,直到NULL;( 所以记录点是很重要的! )

 

//!前面找f的过程很简单,就省略,传递参数f过去

//! 下面就是递归找合适的元素!

Node  getNode(pTree  t, double f )

{

      if( f >= t->value )

      {

             if( t->rChild == NULL )

             {

                    return t->parent;  //!找到???

}

return  getNode( t->rChild, f);

}

else

{

  if( t->lChild = NULL)

      {

        return  t; //! 找到

}

 

return  getNode( t->lChild, f);

}

}

 

 

15、一个整数数列,元素取值可能是1~N(N是一个较大的正整数)中的任意一个数,相同数值不会重复出现。
设计一个算法,找出数列中符合条件的数对的个数,满足数对中两数的和等于N+1。
复杂度最好是O(n),如果是O(n2)则不得分。

//! 首先我们还是要排序呀!

//!然后我的想法是,设置一个low和一个high的标号分别从第一位和最后以为开始靠拢性遍历,以low位数为基准(当然以高位也是一样的),寻找符合N+1条件匹配的high数,我们知道,既然是排序(从小到大 )的,if low匹配的数是high,那么low+1的匹配的数如果存在必然是<high,不然就不可能满足N+1的条件了是吧,这是小学数学知识!经过分析,知道主要时间在排序上,是O(nlog(n) );--àif用归并算法,可以接近O(n)/

CODE:

void   findNum( int num[],int size )

{

      int  low = 0, high = size – 1;

      while( low < high ) 

      {

             while( num[low] + num[high]  > N +1 && low <high 

             //!还很大,所以high还要再小一点才可以

{

   high--;

}

while( num[low] + num[high] < N + 1&& low < high) 

//! 说明low元素是没有可以匹配的

{

            low++;

}

if( num[low] + num[high] == N + 1 && low < high)

{

            //! 找到一对咯~~~

            low++;

            high--;

}

}

}


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

求个质因数叭O(∩_∩)O

题目是这样的:D. Soldier and Number Gametime limit per test 3 secondsmemory limit per test 256 megabytesi...

QQ活动助手,通过作者也就是我搜集各种QQ有关的活动,整理成软件的形式让大伙参加,实现一键参与和抽奖的一款小软件。。O(∩_∩)O~不过涉及的东西还是挺多的

该软件我可暂时不会开源的哦。。。因为。。你们懂的。。虽然做法也是很简单的。。 首先需要我们自己写一个HttpHelper...来发送和接收数据!~~ 然后。。你还需要做POST登录QQ的类...

ListView滑动删除效果极简实现O(∩_∩)O哈哈~

无图无真相,上图。 图片太大了,截掉了点。 界面很简单,就两个view。咳咳首先,要想很容易的理解这部分的代码,应该熟悉android的消息派发机制(尤其是dispatchTouchEvent...
  • nvnnv
  • nvnnv
  • 2016-05-19 19:23
  • 147

程序员面试题精选100题(16)-O(logn)求Fibonacci数列[算法]

转载自:http://zhedahht.blog.163.com/blog/static/25411174200722991933440/题目:定义Fibonacci数列如下: 输入n,用最快的方法...

程序员面试题精选100题(16)-O(logn)求Fibonacci数列[算法]

题目:定义Fibonacci数列如下:         /  0           ...

程序员面试题精选100题(16)-O(logn)求Fibonacci数列[算法]

题目:定义Fibonacci数列如下:                /  0        ...
  • dayuqi
  • dayuqi
  • 2012-09-18 13:28
  • 1370

【数据结构】栈面试题---以O(1)时间复杂度求最小值

假设给出一组数字,我们需要在O(1)时间复杂度内完成对这组数字最小值的求解。 题目具体描述:定义栈的数据结构,请在该类型中实现一个能够得到栈的最小值元素的min函数。在该栈中,调用min, push和...

程序员面试题精选100题(16)-O(logn)求Fibonacci数列[算法]

题目:定义Fibonacci数列如下:         /  0            ...

栈和队列面试题(二)--- 实现一个栈,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作) 的时间复杂度为O(1)

一、 实现一个栈,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作) 的时间复杂度为O(1) (1)栈的基本操作入栈(push);出栈(pop);查找栈顶(top);栈的元素个数(...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)