4-数组-案例实战

扩展数组

扩展数组一般通过为Array 对象定义原型方法来实现，这些原型方法能被所有数组继承。

Array.prototype.hello=function(){
    console.log("hello!")
}
var a=[1,2,3]
var b=[]
a.hello()
b.hello()
//结果：
//hello！
//hello！

【例】为数组扩展一个求所有元素之和的方法

Array.prototype._sum=Array.prototype.sum||  //检测是否存在同名方法
(Array.prototype._sum=function(){  //定义该方法
    var _n=0;  //临时汇总变量
    for(var i in this){  //遍历当前数组对象
        if(this[i]=parseFloat(this[i]))  //若数组元素是数字
            _n+=this[i];  //则进行累加            
    }
    return _n; //返回累加的和
});
Object.prototype.sum=Array.prototype._sum;  //将数组临时原型方法赋值给对象的原型方法
var a=[1,2,3,4,5,6,7,8,'9']
console.log(a.sum())
//结果：
//45

上述代码数组第九个元素是一个字符串类型的数字，汇总时也被转换为数值进行累加。

---

数组去重

var a=[2,3,43,43,554,3,32,4,43,2]
console.log([...new Set(a)])
//结果：
// [ 2, 3, 43, 554, 32, 4 ]

---

插入排序

1.从第一个元素开始，该元素默认为已经被排序
2.取出下一个元素，在已排序的序列中从后向前扫描
3.若已排序的元素大于新元素（temp），将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或等于新元素
5.将新元素插入到该位置后
6.重复步骤2~5

function insertsort(arr){ //从小到大
    for(var i=1;i<arr.length;i++){ 
        var j=i-1;  
        var temp=arr[i];  
        while(j>=0&&temp<=arr[j]){  
            arr[j+1]=arr[j];  
            j--;  
        }            
        arr[j+1]=temp;
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(insertsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

二分插入排序

二分插入（binary-insert-sort）排序是一种在直接插入排序算法上进行改动的排序算法。使用二分查找的方式，在速度上有一定提升。

1.从第一个元素开始，该元素默认为已经被排序
2.取出下一个元素，在已排序的序列二分查找到第一个比它大的数的位置
3.将新元素插入到该位置后
4.重复上述两步

function binaryinsertsort(arr){ //从小到大
    for(var i=1;i<arr.length;i++){
        var left=0,right=i-1;
        var temp=arr[i];
        while(left<=right){
            var middle=parseInt((left+right)/2);
            if(temp<arr[middle]){
                right=middle-1;
            }
            else{
                left=middle+1;
            }
        }
        for(var j=i-1;j>=left;j--){
            arr[j+1]=arr[j];
        }
        arr[left]=temp;
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(binaryinsertsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

选择排序

首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余未排序的元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。

function selectsort(arr){ //从小到大   
    for(var i=0;i<arr.length-1;i++){
        var temp=arr[i];
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<temp) {
                temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }            
        }
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(selectsort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，若它们的顺序错误就把它们交换过来。

1.比较相邻的元素。若第一个比第二个大，则交换
2.对每一对相邻元素作同样的工作，从开始第一对到结尾最后一对
3.针对所有元素重复以上步骤，除了最后一个
4.重复步骤1~3，直到排序完成

function bubblesort(arr){ //从小到大   
    for(let i=0;i<arr.length-1;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                let temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    return arr;
}
var a=[1,5,3,5,2,9,7];
console.log(bubblesort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

快速排序

快速排序使用分治法来把一个串（list）分为两个串。

1.从数列中挑出一个元素，称为“基准”
2.重新排序数列，所有元素比基准值小的摆放在基准值前面，所有元素比基准值大的摆在基准值后面（相同的数可以到任意一边）。在这个分区退出后，该基准就处于数列的中间位置。这个称为分区操作。
3.地柜地把小于基准值元素的子数列和大于基准值的子数列排序。

function quicksort(arr){ //从小到大   
    if(arr.length<=1){return arr;}
    var left=[];
    var right=[];
    var num=arr[0];
    for(var i=1;i<arr.length;i++){
        if(arr[i]<=num){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quicksort(left).concat([num],quicksort(right));    
}
var a=[1,5,3,5,2,9,7];
console.log(quicksort(a))
//[  1, 2, 3, 5,  5, 7, 9]

---

计数排序

计数排序是一种稳定的算法。使用一个额外数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

1.找出待排序数组中最大和最小的元素
2.统计数组中每个值为i的元素出现的次数，存入数组的第i项
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
4.反向填充目标数组：将每个元素i放在新数组的第C（i）项，每放一个元素就将C（i）减去1

function countsort(arr){ //从小到大   
    var max=min=arr[0];
    var B=[],C=[];
    for(var i=0;i<arr.length;i++){
        max=max>=arr[i]?max:arr[i];
        min=min<=arr[i]?min:arr[i];
        C[arr[i]]=C[arr[i]]?C[arr[i]]+1:1;
    }
    for(var j=min;j<max;j++){
        C[j+1]=(C[j+1]||0)+(C[j]||0);
    }
    for(var k=arr.length-1;k>=0;k--){
        B[C[arr[k]]-1]=arr[k];
        C[arr[k]]--;
    }
    return B;    
}
var a=[1,5,3,5,2,9,7];
console.log(countsort(a))
//[  1, 2, 3, 5,  5, 7, 9]