448.Find All Numbers Disappeared in an Array
這是leetCode第448題
題目
Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.
Find all the elements of [1, n] inclusive that do not appear in this array.
Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.
大致意思是：
給一個由1到n整數組成的數組（n為數組長度），某些數字會出現2（可以是2次以上）次，某些數字會出現1次。（如果每個數字都只出現一次的話，數組應該包含1～n的所有整數，因為有些數字出現了2次或2次以上，導致一些數字不能被包含在n長度的數組中。）
找出1～n中，所有沒有出現在數組中的數字。
你能不使用額外的空間，用O(n)的時間復雜度來解決問題嗎？你可以假設返回的數組不算額外空間。
Example:
Input:
[4,3,2,7,8,2,3,1]
Output:
[5,6] //5和6沒有包含在數組中，數組長度為8。
我的思路：
哎，我使用了額外的空間，想不出不使用額外空間的算法。
1.以數組中的每個數字作為對象result的屬性和值
2.然后遍歷1到n，如果result[i]不是undefined，說明之前數組就存在這個數字i。如果result是undefined，說明，這個數字i，之前不在數組中。
var findDisappearedNumbers = function(nums) {
var result = [];
var n = nums.length;
var r = [];
for(var i=0;i<n;i++){
result[nums[i]]=nums[i];
}
for(i=1;i<=n;i++){
if(result[i]===undefined){
r.push(i);
}
}
return r;
};
沒有使用額外空間的算法：
下面是別人的代碼：
var findDisappearedNumbers = function(nums) {
var n = nums.length;
var res = [];
for (var i = 0; i < n; i ++){
nums[(nums[i]-1) % n] += n;
}
for (var i = 0; i <n; i ++) {
if (nums[i] < =n){
res.push(i+1);
}
}
return res;
};
算法很巧妙，思路是這樣的：
- 循環數組，(nums[ i ]-1)%n 得到的是1-n之間的整數（原始的數字，因為可能會被加n），然后把這個整數對應的數組位置的值加上n。為什么要取模，因為這個位置的數字很有可能會被加n，取了模得到值就是原來的數字。
這樣做的結果就是，只要數組中出現過的數字，該數字減1對應的位置，都加了至少一次n( 如果某個數字出現多次，其對應的位置上的數字就會被加多次n)。所以這個位置的數字就一定大于n。
2.再次循環數組，將當前位置i的數字與n進行比較。如果數字小于等于n，就說明i+1不存在數組中。因為如果i+1這個數字存在數組中，那么在第一步的時候，就一定會將i（通過num[i]+=n改變）位置的數字加n。
簡單的講就是，數組中存在的數字a都對將a-1位置的整數加上n。所以，數組中的整數大于n了，說明被加了n，那么其索引+1對應的整數就存在數組中。反之，數組中的整數小于等于n,就說明其索引+1對應的整數，不存在數組中。
第二種算法的思路不太直觀，一眼看去很難明白它的邏輯。盡管這樣，它確實沒有使用額外的空間。
測試下兩個算法的效率
執行下面的代碼，來生成一個模塊Array.js，該模塊導出一個長度為10000000的數組，數組中的整數在1到10000000之間。
node product.js
product.js文件的代碼如下：
var fs = require("fs");
var nums =[];
var boundary = 10000000;
for(var i=0;i<boundary;i++){
nums.push(Math.floor(Math.random()*boundary));
}
//轉成字符串
var str = "var array=["+nums+"];module.exports=array;";
//寫入Array.js文件，生成了js代碼
fs.writeFile('Array.js', str, function(err) {
if (err) {
return console.error(err);
}
console.log("數據寫入成功！");
});
使用如下代碼進行測試：
var nums = require('./Array.js');
var start = new Date().getTime();
//這里就打印結果數組的長度，因為數組太長了。
console.log('length:'+findDisappearedNumbers(nums).length);
var end = new Date().getTime();
console.log('time: '+(end - start));
第一種算法的結果如下：
length:3679312
time: 1461
第二種算法的結果如下：
length:3679312
time: 440
第二種算法的時間明顯更快。原因可能是，我的算法使用了額外的空間來儲存數據，每次儲存都需要開辟新的內存，或許比較耗時。而第二種是在原來的基礎上修改的，或許省力吧。
下面驗證一下我的猜想
計算使用新定義的數組來儲存10000000個1花費的時間,測試3次。
var nums = require('./Array.js');
var start = new Date().getTime();
var newArray = [];
for(var i=0;i<10000000;i++){
newArray[i]=1;
}
var end = new Date().getTime();
console.log('time: '+(end-start));
3次結果分別如下：
time: 238
time: 226
time: 228
計算在原來的數組上儲存10000000個1話費的時間，測試3次。
var nums = require('./Array.js'); // 長度為10000000
var start = new Date().getTime();
var newArray = [];
for(var i=0;i<10000000;i++){
nums[i]=1;
}
var end = new Date().getTime();
console.log('time: '+(end-start));
3次結果分別如下：
time: 70
time: 72
time: 64
結論：在原來的數組上儲存數據更加高效。
因此在算法中減少額外空間的使用，能提高算法的效率。
