// 在陣列中查詢一個東西是否存在
function findInArr (item, arr) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] == item) {
            return true;
        }
    }
    return false;
}

//數組裡找最小值
function findMin (arr, start) {
    var count = arr[start];
    for (var i = start + 1; i < arr.length; i++) {
        if (arr[i] < count) {
            count = arr[i];
        }
    }
    return count;
}

// 氣泡排序
function bubbleSort (arr) {
    /**
     * 第二個迴圈裡面就是每次都跟自己前一個比看是大還是小（看自己的需求）    就掉換位置就Ok了
     * */
    var i, j, len = arr.length;
    for (i = 0; i < len; i++) {
        for (j = 0; j < len; j++) {
            if (arr[j] > arr[j + 1]) {//拿當前這一個跟後面一個比(>從小到大)（<從大到小）
                var tmp;
                tmp = arr[j];//把當前的儲存
                arr[j] = arr[j + 1];//掉換順序
                arr[j + 1] = tmp;
            }
        }
    }
    return arr;
}

// 並歸排序  用的是二分法    eg: document.write(margeSort(arr,0,arr.length));
function margeSort (arr, s, e) {//s開始位置e結束位置
    var s = s || 0;
    var e = e || arr.length;
    if (s > e) {//開始大於啊結束
        return [];
    } else if (s == e) {//開始位置等於位置只有一位數
        return [arr[s]];
    } else if (s == e - 1) {//只有兩位數的情況下

        if (arr[s] < arr[e]) {
            return [arr[s], arr[e]];
            //現在排的是從小到大  其它反之
        } else {
            return [arr[e], arr[s]];
        }
    }

    //取箇中間位置分成兩邊  ceil向上取整
    var c = Math.ceil((s + e) / 2);
    var left = margeSort(arr, s, c);//自己掉用自己返回排好的順序
    var right = margeSort(arr, c + 1, e);
    var aResult = [];

    while (left.length && right.length) {

        //把兩個陣列排好的序 進行整合
        if (left[0] < right[0]) {
            aResult.push(left.shift());
        } else {
            aResult.push(right.shift());
        }

        //其中有一個數組空了就把別一個剩下的整合
        if (left.length == 0) {
            aResult = aResult.concat(right);
        } else if (right.length == 0) {
            aResult = aResult.concat(left);
        }
    }

    return aResult;

}

// 快速排序
function quickSort (arr) {
    /**
     * 把陣列分成兩半    在使用遞迴方法
     */
    if (arr.length == 0) {
        return [];//返回一定是個空陣列  不然會報錯  因為在後面cancat的時候不是陣列就錯了
    }

    var index = Math.floor(arr.length / 2);//求出一箇中間位置
    var c = arr.splice(index, 1);//中間位置的數值  用於做比較
    var left = [];
    var right = [];

    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < c) {//這裡看自己需求  看是從大到小還是從小到大
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }

    return quickSort(left).concat(c, quickSort(right));//分成了多段  直到執行完為止   一直在自己掉用自己

}

// 選擇排序
function selectionSort (arr) {
    /**
     *  找最小或者最大的(看自己需求) 返回變化位置就好了
     */
    function findMinIndex (arr, index) {
        var iMin = arr[index];//當前查詢的那一個的值
        var iMinIndex = index;

        for (var i = index; i < arr.length; i++) {
            if (iMin > arr[i]) {//找比自己小的 如果找到了就把自己變成那個最小的
                iMin = arr[i];
                iMinIndex = i;//把最小的位置儲存下來  用於返回
            }
        }
        return iMinIndex;
    }

    for (var i = 0; i < arr.length; i++) {
        var index = findMinIndex(arr, i);//找最小值的位置
        var tmp = arr[i];//把當前這一個儲存起來; 用於變位置後賦值
        arr[i] = arr[index];
        arr[index] = tmp;
    }
    return arr;
}

function sort (arr) {
    return arr.sort(function (n1, n2) {//排出來的沒用字母是a-z  這樣排的
        return n1 - n2;//從小到大排         數字可以用
        //return n2-n1;//從大到小排
    })
}

// 刪除奇數
function deleteOdd (arr) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] % 2 == 1) {
            arr.splice(i, 1);
            i--;
        }
    }
    return arr;
}

// 刪除偶數
function deleteEven (arr) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] % 2 == 0) {
            arr.splice(i, 1);
            i--;
        }
    }
    return arr;
}

// 陣列去重
function unique (arr) {
    var res = [];
    var json = {};
    for (var i = 0; i < arr.length; i++) {
        if (!json[arr[i]]) {
            res.push(arr[i]);
            json[arr[i]] = 1;
        }
    }
    return res;
}

function unique2 (arr) {
    arr.sort();
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] == arr[i + 1]) {
            arr.splice(i, 1);
            i--;
        }
    }
    return arr;
}

function unique3 (arr) {
    function findInArr (itme, arr) {
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] == itme) {
                return true;
            }
        }
        return false;
    }

    var arr2 = [];
    for (var i = 0; i < arr.length; i++) {
        if (!findInArr(arr[i], arr2)) {
            arr2.push(arr[i]);
        }
    }
    return arr2;
}

function unique4 (arr) {
    var res = [arr[0]];
    for (var i = 1; i < arr.length; i++) {
        if (res.indexOf(parseInt(arr[i])) == -1) {
            res.push(arr[i]);
        }
    }
    return res;
}

// 陣列亂序
/**
 var array = [1, 2, 3, 4, 5];
 console.log(array.sort(compare));//[2,1,5,4,3]
 * */
function compare () {
    return Math.random() - 0.5; // 每次返回一個隨機數讓陣列亂序
}

// ------------------------------------------------------------------
// 隨機整數
function getRandomInt (min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min);
}

// 陣列亂序
function shuffle (arr) {
    let _arr = arr.slice();
    for (let i = 0; i < _arr.length; i++) {
        let j = getRandomInt(0, i);
        let t = _arr[i];
        _arr[i] = _arr[j];
        _arr[j] = t;
    }
    return _arr;
}

// ------------------------------------------------------------------
// 處理陣列上相容問題

// every()：對陣列中的每一項執行給定函式，如果每一項都返回true，則返回true，否則false；
if (typeof Array.prototype.every != "function") {
    Array.prototype.every = function (fn, context) {
        var passed = true;
        if (typeof fn === "function") {
            for (var k = 0, length = this.length; k < length; k++) {
                if (passed === false) break;
                passed = !!fn.call(context, this[k], k, this);
            }
        }
        return passed;
    };
}
// some()：對陣列中的每一項執行給定函式，如果至少有一項返回true，則返回true，否則false；
if (typeof Array.prototype.some != "function") {
    Array.prototype.some = function (fn, context) {
        var passed = false;
        if (typeof fn === "function") {
            for (var k = 0, length = this.length; k < length; k++) {
                if (passed === true) break;
                passed = !!fn.call(context, this[k], k, this);
            }
        }
        return passed;
    };
}
// filter()：對陣列中的每一項給定函式，返回值為true的項重新組成新的陣列；
if (typeof Array.prototype.filter != "function") {
    Array.prototype.filter = function (fn, context) {
        var arr = [];
        if (typeof fn === "function") {
            for (var k = 0, length = this.length; k < length; k++) {
                fn.call(context, this[k], k, this) && arr.push(this[k]);
            }
        }
        return arr;
    };
}
// map()：歲陣列中的每一項給定函式，返回每一項呼叫這個函式的結果；
// map()方法還可以接受第二個引數，表示回撥函式執行時this所指向的物件
/*var arr = ['a','b','c'];
[1,2].map(function(item,index,arr){return this[item]},arr);//['b','c']*/
//map()方法相容寫法
if (typeof Array.prototype.map != "function") {
    Array.prototype.map = function (fn, context) {
        var arr = [];
        if (typeof fn === "function") {
            for (var k = 0, length = this.length; k < length; k++) {
                arr.push(fn.call(context, this[k], k, this));
            }
        }
        return arr;
    };
}
// forEach()：對方法中的每一項執行給定函式。這個方法沒有返回值；
if (typeof Array.prototype.forEach != 'function') {
    Array.prototype.forEach = function (fn, context) {
        for (var k = 0, length = this.length; k < length; k++) {
            if (typeof fn === 'function' && Object.prototype.hasOwnProperty.call(this, k)) {
                fn.call(context, this[k], k, this);
            }
        }
    }
}
// reduce()方法相容寫法
/**
 var nums=[1,2,3,4,5];
 var sum=nums.reduce(function(prev,cur,index,array){
        return prev+cur;
    });
 alert(sum);      //15     第一次 prev:1;cur:2; 第二次： prev:3(1+2)  cur:3  以此類推
 * */
if (typeof Array.prototype.reduce != "function") {
    Array.prototype.reduce = function (callback, initialValue) {
        var previous = initialValue, k = 0, length = this.length;
        if (typeof initialValue === "undefined") {
            previous = this[0];
            k = 1;
        }
        if (typeof callback === "function") {
            for (k; k < length; k++) {
                this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
            }
        }
        return previous;
    };
}

// reduceRight()方法相容寫法
/**
 var nums=[1,2,3,4,5];
 var sum=nums.reduceRight(function(prev,cur,index,array){
        return prev+cur;
    });
 alert(sum);      //15     第一次 prev:5;cur:4; 第二次： prev:9(5+4)  cur:3  以此類推
 * */
if (typeof Array.prototype.reduceRight != "function") {
    Array.prototype.reduceRight = function (callback, initialValue) {
        var length = this.length, k = length - 1, previous = initialValue;
        if (typeof initialValue === "undefined") {
            previous = this[length - 1];
            k--;
        }
        if (typeof callback === "function") {
            for (k; k > -1; k -= 1) {
                this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
            }
        }
        return previous;
    };
}
//　indexOf()方法相容寫法
/**
 // indexOf()   第一個引數是查詢的東西  第二個引數是從哪裡開始找起
 [1,2,3,4,5].indexOf(2); //返回的是   1  沒有就返回 -1
 * */
if (typeof Array.prototype.indexOf != "function") {
    Array.prototype.indexOf = function (searchElement, fromIndex) {
        var index = -1;
        fromIndex = fromIndex * 1 || 0;
        for (var k = 0, length = this.length; k < length; k++) {
            if (k >= fromIndex && this[k] === searchElement) {
                index = k;
                break;
            }
        }
        return index;
    };
}