微软的22道数据结构算法面试题（含答案）

微软的22道数据结构算法面试题（含答案）

  1、反转一个链表。循环算法。  

   

   

    1     List   reverse(List   l)   { 

    2     if(!l)   return   l;  

    3     list   cur   =   l.next;  

    4     list   pre   =   l;  

    5     list   tmp;  

    6     pre.next   =   null;  

    7     while   (   cur   )   { 

    8         tmp   =   cur;  

    9         cur   =   cur.next; 

  10         tmp.next   =   pre;  

  11         pre   =   tmp;  

  12     }  

  13     return   tmp;  

  14   }  

   
  2、反转一个链表。递归算法。  

   

  1     List   resverse(list   l)   {  

  2     if(!l   ||   !l.next)   return   l; 

  3          

  4         List   n   =  reverse(l.next);  

  5         l.next.next   =   l;  

  6         l.next=null;  

  7     }  

  8     return   n;  

  9   }  

   

   
  3、广度优先遍历二叉树。  

    1     void   BST(Tree   t)   {  

    2     Queue   q   =   new  Queue();  

    3     q.enque(t);  

    4     Tree   t   =   q.deque();     

    5     while(t)   {  

    6         System.out.println(t.value);  

    7         q.enque(t.left);  

    8         q.enque(t.right);  

    9         t   =   q.deque();  

  10     }  

  11   }  

  ----------------------  

    1class   Node   {  

    2     Tree   t;  

    3     Node   next;  

    4   }  

    5class   Queue   {  

    6     Node   head;  

    7     Node   tail;  

    8     public   void   enque(Tree   t){ 

    9         Node   n   =   new  Node();  

  10         n.t   =   t;  

  11         if(!tail){  

  12             tail   =   head  =   n;  

  13         }   else   {  

  14         tail.next   =   n;  

  15         tail   =   n;  

  16         }  

  17     }  

  18     public   Tree   deque()   {  

  19         if   (!head)   {  

  20                 return  null;  

  21         }   else   {  

  22         Node   n   =   head; 

  23         head   =   head.next;  

  24       return   n.t;  

  25         }  

  26}  

4、输出一个字符串所有排列。注意有重复字符。  

   

    1char[]   p;  

    2void   perm(char   s[],   int   i,  int   n){  

    3   int   j;  

    4   char   temp;  

    5   for(j=0;j<n;++j){  

    6     if(j!=0   &&   s[j]==s[j-1]); 

    7     elseif(s[j]!='@'){  

    8       p[i]=s[j];  

    9       s[j]='@';  

  10       if(i==n-1){  

  11         p
='\0';  

  12         printf("%s",   p);  

  13       }else{  

  14         perm(s,i+1,n);  

  15       }  

  16       s[j]=p[i];  

  17     }  

  18   }  

  19}  

  --------------------------  

  1void   main()   {  

  2     char   s
;  

  3     sort(s);  

  4     perm(s,0,strlen(s));  

  5}  

   

   
  5、输入一个字符串，输出长型整数。  

   

    1   long   atol(char   *str){  

    2         char   *p   =   str; 

    3         long   l=1;m=0;  

    4         if   (*p=='-')   {  

    5                 l=-1; 

    6                 ++p; 

    7         }  

    8         while(isDigit(*p)){  

    9                 m  =   m*10   +   p;  

  10                 ++p;  

  11         }  

  12         if(!p)   return   m*l;  

  13         else   return   error;  

  14}  

   

   
  6、判断一个链表是否有循环。  

   

  1       int     isLoop(List   l)    {  

  2             if   (   !  l)     return       -   1   ;  

  3           List   s     =    l.next;  

  4               while   (s    &&     s   !=   l)      {  

  5                   s    =     s.next;  

  6           }    

  7             if     (   !  s)     return       -   1   ;  

  8             else     reutrn    1   ;  

  9   }    

  -----------  

    1int   isLoop(List   l){  

    2         if(!l)   return   0; 

    3         p=l.next;  

    4         wihle(p!=l&&p!=null)  {  

    5                l.next=l;  

    6                l=p;p=p.next;  

    7         }  

    8         if(p=l)   return   1; 

    9         return   0;  

  10}  

  实际上，在我的面试过程中，还问到了不破坏结构的其他算法。  

  我的答案是从链表头开始遍历，如果节点next指针指向自身，则循环存在；否则将next指针指向自身，遍历下一个节点。直至next指针为空，此时链表无循环。
 

   

   
  7、反转一个字符串。 

   

    1       void     reverse(   char      *   str)     {  

    2             char    tmp;  

    3             int    len;  

    4           len     =    strlen(str);  

    5               for   (  int     i   =   0   ;i   <   len  /   2   ;   ++   i)     {  

    6                  tmp   =   char   [i];  

    7                  str[i]     =     str[len   -   i   -  1   ];  

    8                   str[len  -   i   -   1   ]   =   tmp;  

    9           }    

  10   }    

   
  8、实现strstr函数。  

   

    1int   strstr(char[]   str,   char[]   par){ 

    2         int   i=0;  

    3         int   j=0;  

    4         while(str[i]   &&  str[j]){  

    5                if(str[i]==par[j]){  

    6                        ++i;  

    7                        ++j;  

    8                 }else{ 

    9                        i=i-j+1;  

  10                        j=0;  

  11                 }  

  12         }  

  13         if(!str[j])   return  i-strlen(par);  

  14         else   return   -1;  

  15}

9、实现strcmp函数。  

   

  1int   strcmp(char*   str1,   char*   str2){  

  2         while(*str1   &&   *str2  &&   *str1==*str2){  

  3                 ++str1;  

  4                 ++str2;  

  5         }  

  6         return   *str1-*str2;  

  7}  

   

   
  10、求一个整形中1的位数。  

   

  1       int     f(   int     x)    {  

  2             int     n   =  0   ;  

  3               while   (x)    {  

  4                    ++   n;  

  5                   x  &=   x   -   1   ;  

  6           }    

  7        
cd79
    return     n; 

  8   }    

   
  
  11、汉诺塔问题。  

   

  1void   tower(n,x,y,z){  

  2         if(n==1)   move(x,z);  

  3         else   {  

  4                 tower(n-1,  x,z,y);  

  5                 move(x,z); 

  6                 tower(n-1,  y,x,z);  

  7         }  

  8}  

   

   
  12、三柱汉诺塔最小步数。 

   

    1       int     f3(n)     { 

    2             if   (f3
)    return     f3
;  

    3               else        {  

    4                      if   (n   ==   1   )     {  

    5                          f3
  =   1   ;  

    6                            return       1   ; 

    7                  }    

    8                  f3
  =   2   *   f3(n   -   1   )  +   1   ;  

    9                    return     f3
;  

  10           }    

  11   }    

   

  四柱汉诺塔最小步数。  

    1int   f4(n){  

    2         if(f4
==0){  

    3                if(n==1)   {  

    4                        f4[1]==1;  

    5                        return   1;  

    6                 } 

    7                min=2*f4(1)+f3(n-1);  

    8                 for(int  i=2;i<n;++i){  

    9                        u=2*f4(i)+f3(n-i);  

  10                        if(u<min)   min=u;  

  11                 }  

  12                 f4
=min; 

  13                 return  min;  

  14         }   else   return   f4
; 

  15}  

   

   

  13、在一个链表中删除另一个链表中的元素。  

   

    1void   delete(List   m,   List   n)   { 

    2         if(!m   ||   !n)  return;  

    3         List   pre   =   new  List();  

    4         pre.next=m;  

    5         List   a=m,  b=n,head=pre;  

    6         while(a   &&  b){  

    7                if(a.value   <   b.value)   {  

    8                        a=a.next;  

    9                        pre=pre.next;  

  10                 }else  if(a.value   >   b.value){  

  11                        b=b.next;  

  12                 }else{  

  13                        a=a.next;  

  14                        pre.next=a;  

  15                 }  

  16         }  

  17         m=head.next;  

  18}

 14、一个数组，下标从0到n，元素为从0到n的整数。判断其中是否有重复元素。
 

   

    1int   hasDuplicate(int[]   a,   int   n){ 

    2         for(int   i=0;i<n;++i){ 

    3                while(a[i]!=i   &&   a[i]!=-1){  

    4                        if(a[a[i]]==-1)   return   1;  

    5                        a[i]=a[a[i]];  

    6                        a[a[i]]=-1;  

    7                 } 

    8                if(a[i]==i)   {a[i]=-1;}  

    9         }  

  10         return   0;  

  11}  

   

   
  15、判断一颗二叉树是否平衡。  

   

  1int   isB(Tree   t){  

  2         if(!t)   return   0;  

  3         int   left=isB(t.left);  

  4         int   right=isB(t.right);  

  5         if(   left   >=0  &&   right   >=0   &&   left   -  right   <=   1   ||   left   -right  >=-1)  

  6                 return  (left<right)?   (right   +1)   :   (left   +  1);  

  7         else   return   -1;  

  8}  

  9  

   

   
  16、返回一颗二叉树的深度。  
   

  1int   depth(Tree   t){  

  2         if(!t)   return   0;  

  3         else   {  

  4                 int  a=depth(t.right);  

  5                 int  b=depth(t.left);  

  6                 return  (a>b)?(a+1):(b+1);  

  7         }  

  8}  

   

   
  17、两个链表，一升一降。合并为一个升序链表。  

   

    1       List   merge(List   a,  List   d)     {  

    2           List   a1   =  reverse(d);  

    3           List   p    =     q     =       new    List();  

    4               while    (   a     &&     a1   )      {  

    5                      if   (a.value   <   a1.value)     { 

    6                          p.next   =   a;  

    7                          a   =   a.next;  

    8                    }       else         {  

    9                          p.next   =   a1;  

  10                          a1   =   a1.next;  

  11                   }   

  12                   p  =   p.next;  

  13           }    

  14             if   (a)   p.next    =     a;  

  15           elseif(a1)   p.next   =  a1;  

  16             return    q.next;  

  17   }    

   

   

  18、将长型转换为字符串。 

   

    1char*   ltoa(long   l){  

    2         char
  str;    

    3         int   i=1,n=1;  

    4         while(!(l/i<10)){i*=10;++n} 

    5         char*  str=(char*)malloc(n*sizeof(char));  

    6         int   j=0;  

    7         while(l){  

    8                str[j++]=l/i;  

    9                 l=l%i; 

  10                 i/=10;  

  11         }  

  12         return   str;  

  13}  
19、用一个数据结构实现 

  1   if   (x   ==   0)   y   =   a; 

  2   else   y   =   b;  

   

  1   j[]   =   {a,b};  

  2   y=j[x];  

   

   
  20、在双向链表中删除指定元素。  

   

    1void   del(List   head,   List   node){ 

    2         List   pre=new   List(); 

    3         pre.next   =   head; 

    4         List   cur   =  head;  

    5         while(cur   &&  cur!=node){  

    6                cur=cur.next;  

    7                pre=pre.next;  

    8         }  

    9         if(!cur)   return;  

  10         List   post   =  cur.next;  

  11         pre.next=cur.next;  

  12         post.last=cur.last;  

  13         return;  

  14}  
  
  21、不重复地输出升序数组中的元素。  

   

    1       void     outputUnique(  char   []   str,   int     n)     {  

    2             if   (n  <=   0   )     return   ;  

    3           elseif(n   ==   1  )   putchar(str[   0   ]);  

    4               else        {  

    5                    int     i   =   0   ,j   =   1  ;  

    6                  putchar(str[   0   ]);  

    7                      while   (j   <   n)     {  

    8                              if   (str[j]   !==  str[i])     {  

    9                                  putchar(str[j]);  

  10                                  i   =   j;  

  11                          }    

  12                            ++   j;  

  13                   }   

  14           }    

  15   }    

标注：分享链接http://blog.csdn.net/thisispan/article/details/7473062