JavaScript内置对象Array的扩展(去重，排序，合并)

JS的一大灵活之处就在于可以对内置对象进行扩展，添加属于自己的方法，本文将使用常见的算法对Array进行若干扩展！

1，去重复

1.1，使用Array本身就有的indexOf方法:

Array.prototype.uniqeu = Array.prototype.uniqeu || function() {
var aRet = [];
for (var i = 0, len = this.length; i < len; i++) {
if (aRet.indexOf(this[i]) === -1) {
aRet.push(this[i]);
}
}
return aRet;
};

2.2，循环遍历数组，同时建立一个json对象，记录是否重复，高效！

Array.prototype.uniqeu = Array.prototype.uniqeu || function() {
var aRet = [];
var json = {};
for (var i = 0, len = this.length; i < len; i++) {
if (!json[this[i]]) {
aRet.push(this[i]);
json[this[i]] = true;
}
}
console.log(json);
return aRet;
}

2，排序

2.1，冒泡排序



从上图中可以看出，冒泡排序的循环是分两层的，即一个外层一个内层，外层循环每次排好一个就是把当前最大的数字‘沉’到最下面，每排好一个数，都要进行内部的一次循环，挨个比较。每次外循环都会排好一个数字，第0次把最大的数排到最后，第1次把次大的数字排好……所以内循环的时候，对于前面已经排好的i个数字就不要继续再排了也就是下面的 j < len - 1 - i;

Array.prototype.bubbleSort = Array.prototype.bubbleSort || function() {
for (var i = 0, len = this.length; i < len - 1; i++) {
for (var j = 0; j < len - i - 1; j++) {
if (this[j] > this[j+1]) {
var t = this[j];
this[j] = this[j+1];
this[j+1] = t;
}
}
}
return this;
}

其实对于上面的排序仍然是不太好的冒泡，如果遇到很坏的情况，上面的排序倒是不错，但如果遇到很好的情况，比如数组本来就是排好序的，那就没必要再折腾下去了，设计一个标志位

Array.prototype.bubbleSort = Array.prototype.bubbleSort || function() {
var bSorted = true;
for (var i = 0, len = this.length; i < len - 1 && bSorted; i++) {
bSorted = false;
for (var j = 0; j < len - 1 - i; j++) {
if (this[j] > this[j+1]) {
var t = this[j];
this[j] = this[j+1];
this[j+1] = t;
bSorted = true;//如果已经排好序了就不存在this[j]>this[j+1]了
}
}
}
return this;
}

2.2，二分查找（折半查找）

用于已经排好序的数组

Array.prototype.binarySearch = Array.prototype.binarySearch || function(aim) {
var low = 0;
var high = this.length - 1;
while(low <= high) {
var mid = Math.ceil((low + high) / 2);
if (aim > this[mid]) {
low = mid + 1;
} else if (aim < this[mid]) {
high = mid - 1;
} else {
return mid;
}
}
return -1;
}

下面附一个递归的二分查找，用于学习

function binarySearch(arr, low, high, target) {
var mid = Math.ceil((low + high)/2);
if (low <= high && low >= 0 && high < arr.length) {
if (target > arr[mid]) {
return binarySearch(arr, mid+1, high, target)
} else if (target < arr[mid]) {
return binarySearch(arr, low, mid-1, target);
} else {
return mid;
}
} else {
return -1;
}
}

合并去重

var arr1 = [1,2,3,4,5];
var arr2 = [3,2,6,7,9];
//合并两个数组
Array.prototype.myConcat = Array.prototype.myConcat || function(arr) {
for (var i = 0; i < arr.length; i++) {
this.indexOf(arr[i]) === -1 ? this.push(arr[i]) : {};
}
return this;
}
alert(arr1.myConcat(arr2));//1,2,3,4,5,6,7,9