一道面试题Lintcode196-Find the Missing Number

http://www.lintcode.com/en/problem/find-the-missing-number/#

Find the Missing Number

Given an array contains N numbers of 0 .. N, find which number doesn't exist in the array.

 

Example

Given N = 3 and the array [0, 1, 3], return 2.

Challenge

Do it in-place with O(1) extra memory and O(n) time.

题意：这是一道面试题目，题意是说给你个数组0-n，让你找出里面唯一缺少的那个数。

思路：我的第一思路是二叉堆，但好像南辕北辙了。可以直接利用快排，少于nlgn的时间就可以找到那个数。利用数值与数组下标的对应关系，数组的数排好序后分两段，左端数值与下标相同，右端则数值比下标大一。不需要排序，只需要借助快排，就可以不断的递归二分这个数组，找出那个奇点。

可以参考两篇类似的博文：

http://www.cnblogs.com/jiu0821/p/4138558.html

http://www.cnblogs.com/jiu0821/p/4505480.html

代码：tle

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int j18(vector<int> &nums,int i,int j){
         int x=nums[i];
         while(){
             while(i<j&&nums[j]>x)  j--;
             if(i<j) nums[i]=nums[j];
             else{
                 nums[i]=x;
                 return i;
             }
             while(i<j&&nums[i]<x)  i++;
             if(i<j) nums[j]=nums[i];
             else{
                 nums[j]=x;
                 return j;
             }
         }
     }
     int findMissing(vector<int> &nums) {
         // write your code
         int i=,j=nums.size()-,y;
         while(y=j18(nums,i,j),){
             if(nums[y]==y) i=y+;
             else j=y-;
             if(i>j) return i;
         }
     }
 };

之所以tle是因为原题目给有特殊数据，代码里默认快排是x为第一个数，遇到最坏情况，复杂度n*n。下面把x改为最后一个数，就ac了。

ac 279ms

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int j18(vector<int> &nums,int i,int j){
         int x=nums[j];
         while(){
             while(i<j&&nums[i]<x)  i++;
             if(i<j) nums[j]=nums[i];
             else{
                 nums[j]=x;
                 return j;
             }
             while(i<j&&nums[j]>x)  j--;
             if(i<j) nums[i]=nums[j];
             else{
                 nums[i]=x;
                 return i;
             }
         }
     }
     int findMissing(vector<int> &nums) {
         // write your code
         int i=,j=nums.size()-,y;
         while(y=j18(nums,i,j),){
             if(nums[y]==y) i=y+;
             else j=y-;
             if(i>j) return i;
         }
     }
 };

当然，这只是投机取巧，也会遇到最坏情况。相对好的方法是取中间或者取随机数。下面是取中间的实现例子：214ms

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int j18(vector<int> &nums,int i,int j){
         int x=nums[(i+j)>>];
         nums[(i+j)>>]=nums[i];
         while(){
             while(i<j&&nums[j]>x)  j--;
             if(i<j) nums[i]=nums[j];
             else{
                 nums[i]=x;
                 return i;
             }
             while(i<j&&nums[i]<x)  i++;
             if(i<j) nums[j]=nums[i];
             else{
                 nums[j]=x;
                 return j;
             }
         }
     }
     int findMissing(vector<int> &nums) {
         // write your code
         int i=,j=nums.size()-,y;
         while(y=j18(nums,i,j),){
             if(nums[y]==y) i=y+;
             else j=y-;
             if(i>j) return i;
         }
     }
 };

最后，说下最直接简单的办法，以空间换时间，加一个bool数组再哈希就可以了。135ms

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int findMissing(vector<int> &nums) {
         // write your code
         int len=nums.size();
         bool numb[len+];
         memset(numb,,sizeof(numb));
         for(int i=;i<len;i++)  numb[nums[i]]=true;
         for(int i=;i<=len;i++){
             if(numb[i]==false)
                 return i;
         }
     }
 };

经好心博友提醒，最优雅的法子横空出世--异或。两个相同的数异或为0。故而把原数组与0-n异或和就为最后的结果。131ms

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int findMissing(vector<int> &nums) {
         // write your code
         int len=nums.size(),x=;
         for(int i=;i<len;i++)  x^=nums[i];
         for(int i=;i<=len;i++) x^=i;
         return x;
     }
 };

看到了官方给的答案---借助桶排序。思路是：从0开始遍历到n-1，每次当a[i]!=i的时候，将a[i]与a[a[i]]交换，大于边界的话，就丢掉，直到无法交换位置。那个特殊值有两种情况，一种是在0~n-1之间，那么经过a[i]与a[a[i]]交换，最后以特殊值为下标的位置上一定为n；另一种是特殊值为n，那么a[i]与a[a[i]]交换对于0~n-1都满足。故而只要跟踪边界值n即可，跟踪值x应初始化为n，以对应第二种情况。详情见代码：

 class Solution {
 public:
     /**
      * @param nums: a vector of integers
      * @return: an integer
      */
     int findMissing(vector<int> &nums) {
         // write your code
         int len=nums.size(),x=len;
         for(int i=;i<len;i++){
             while(nums[i]!=i){
                 if(nums[i]==len){
                     x=i;
                     break;
                 }else{
                     int tmp=nums[nums[i]];//注意这个地方，不能用三个异或来交换值，因为nums[nums[i]]里的nums[i]是变量。
                     nums[nums[i]]=nums[i];
                     nums[i]=tmp;
                 }
             }
         }
         return x;
     }
 };