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