22道数据结构算法面试题.docx
《22道数据结构算法面试题.docx》由会员分享，可在线阅读，更多相关《22道数据结构算法面试题.docx（10页珍藏版）》请在冰豆网上搜索。
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 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[n]='\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[N];
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 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[n]） return f3[n];
3 else {
4 if （n == 1 ） {
5 f3[n] = 1 ;
6 return 1 ;
7 }
8 f3[n] = 2 * f3（n - 1 ） + 1 ;
9 return f3[n];
10 }
11 }
四柱汉诺塔最小步数。
1int f4（n）{
2 if（f4[n]==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 9 u=2*f4（i）+f3（n-i）;
10 if（u 11 }
12 f4[n]=min;
13 return min;
14 } else return f4[n];
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 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 +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 e
升级会员 