JavaScript数组基础编程题归纳

雨点打透心脏的1/2处 2023-08-17 17:45 71阅读 0赞

之前的随笔“**[JavaScript中数组类型的属性和方法][JavaScript]**”中有介绍很多数组类型的方法，但都是一些理论。最近在练习在线编程题，发现自己还是习惯于用常规的循环来答题，对于数组的方法的使用还是不够熟练。这次笔记归纳了一下基础的数组编程题，意在加深对数组各种方法的印象，以便理解使用。

--------------------

**1.计算给定数组arr所有元素的和（number类型）**

*  常规循环
    
        1 function sum(arr) {
        2     var s = 0;
        3     for (var i=arr.length-1; i>=0; i--) {
        4         s += arr[i];
        5     }
        6     return s;
        7 }
 *  forEach()遍历
    
        1 function sum(arr) {
        2     var s = 0;
        3     arr.forEach(function(val, idx, arr) {
        4         s += val;
        5     }, 0);
        6     return s;
        7 };
 *  reduce()归并
    
        1 function sum(arr) {
        2     return arr.reduce(function(prev, curr, idx, arr){
        3         return prev + curr;
        4     });
        5 }
 *  eval()与join()
    
        1 function sum(arr) {
        2     return eval(arr.join("+"));
        3 };

**2.移除指定数组arr中所有与item相等的元素**

*  不修改arr  
    
    
        1 //创建新数组，push()
         2 function remove(arr, item) {
         3     var result = [];
         4     for(var i = 0; i < arr.length; i++){
         5          if(arr[i] != item){
         6             result.push(arr[i]);
         7          }
         8     }
         9     return result;
        10 }
        11  
        12 // filter()迭代
        13 function remove(arr, item) {
        14     return arr.filter(function(x) { return x !== item; });
        15 }
 *  直接修改arr
    
        1 function removeWithoutCopy(arr, item) {
        2     for(var i = 0; i < arr.length; i++){
        3         if(arr[i] == item){
        4             arr.splice(i,1);
        5             i--;
        6         }
        7     }
        8     return arr;
        9 }

**3.在数组arr指定位置添加元素item（不修改arr）**

*  在数组开头添加
    
        1 //****复制数组再添加（concat/slice + unshift/splice）****
         2 function prepend(arr, item) {
         3     var result = arr.concat();   //var result = arr.slice(0);
         4     result.unshift(item);        //result.splice(0,0,item);
         5     return result;
         6 }
         7 
         8 //*****直接拼接****
         9 
        10 //利用concat
        11 function prepend(arr, item) {
        12     return [item].concat(arr);
        13 }
        14 
        15 //使用push.apply
        16 function prepend(arr, item) {
        17     var newArr=[item];
        18     [].push.apply(newArr, arr);
        19     return newArr;
        20 }
 *  在数组末尾添加
    
        1 //普通的迭代拷贝
         2 var append = function(arr, item) {
         3     var newArr = []; 
         4     for (var i = 0; i < arr.length; i++) {
         5         newArr.push(arr[i]);
         6     } 
         7     newArr.push(item); 
         8     return newArr;
         9 };
        10 
        11 // 使用slice浅拷贝+push组合
        12 var append2 = function(arr, item) {
        13     var newArr = arr.slice(0);           // slice(start, end)浅拷贝数组
        14     newArr.push(item);
        15     return newArr;
        16 };
        17 
        18 //使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回
        19 var append3 = function(arr, item) {
        20     return arr.concat(item);
        21 };
 *  在数组index处添加
    
        //复制数组，在添加
        function insert(arr, item, index) {
            var newArr=arr.concat();        //var newArr=arr.slice(0);
                                            //var newArr=[]; [].push.apply(newArr, arr);
            newArr.splice(index,0,item);
            return newArr;
        }
        
        //利用slice+concat
        function insert(arr, item, index) {
            return arr.slice(0,index).concat(item,arr.slice(index));
        }

**4.在数组arr指定位置删除元素（不修改arr）**

*  删除数组开头元素
    
        1 //复制，再删除
         2 function curtail(arr) {
         3     var newArr = arr.concat();  //var newArr = arr.join().split(',');
         4                                 //var newArr=[];  [].push.apply(newArr, arr);
         5     newArr.shift();
         6     return newArr;
         7 }
         8 
         9 //利用filter
        10 function curtail(arr) {
        11     return arr.filter(function(v,i) {
        12         return i!==0;
        13     });
        14 }
        15 
        16 //利用slice
        17 function curtail(arr) {
        18     return arr.slice(1);
        19 }
 *  删除数组末尾元素
    
        1 function truncate(arr) {
        2     return arr.slice(0,arr.length-1);
        3 }

**5.合并数组（不修改arr）**

*  利用concat()
    
        1 function concat(arr1, arr2) {
        2     return arr1.concat(arr2);
        3 }
 *  利用 splice + push.apply
    
        1 function concat(arr1, arr2) {
        2     var newArr=arr1.slice(0);
        3     [].push.apply(newArr, arr2);
        4     return newArr;
        5 }

**6.统计数组arr中元素item出现的次数**

*  常规循环
    
        1 function count(arr, item) {
        2     var sum = 0;
        3     for(var i = 0; i < arr.length; i++){
        4         if( arr[i] == item){
        5             sum ++;
        6         }
        7     }
        8     return sum;
        9 }
 *  利用filter()
    
        function count(arr, item) {
            return arr.filter(function(x){
                return (x==item);
            }).length
        }
 *  利用forEach()
    
        function count(arr, item) {
            var count = 0;
            arr.forEach(function(x) {
                 x === item ? count++ : 0;
             });
             return count;
        }
 *  利用reduce()
    
        1 function count(arr, item) {
        2     var count = arr.reduce(function(prev, curr) {
        3         return curr === item ? prev+1 : prev;
        4     }, 0);
        5     return count;
        6 }

**7.输出数组arr中重复出现过的元素**

*  双循环
    
        1 function duplicates(arr) {
         2     var result = [];
         3     for(var i=0;i<arr.length;i++){
         4         for(var j=i+1;j<arr.length;j++){
         5             if(arr[i]==arr[j]){
         6                 result.push(arr[i]);
         7                 arr.splice(i,1);
         8                 arr.splice(j,1);
         9                 i=i-2;
        10                 j=j-2;
        11             }
        12         }
        13     }
        14     return result;
        15 }
 *  先排序，再循环
    
        1 function duplicates(arr) {
        2     var copy = arr.sort(),
        3         result = [];
        4     for(var i in copy){
        5         if(copy[i]==copy[i-1] && result.indexOf(copy[i])==-1) result.push(copy[i]); 
        6     }
        7     return result;
        8 }
 *  利用forEach()
    
        1 function duplicates(arr) {
        2     var result = [];
        3     arr.forEach(function(elem){
        4        if(arr.indexOf(elem) != arr.lastIndexOf(elem) && result.indexOf(elem) == -1){
        5            result.push(elem);
        6        }
        7     });
        8     return result;
        9 }

**8.数组去重**

1 Array.prototype.uniq = function () {
     2     var flag = false;
     3     for(var i = 0; i < this.length; i++){
     4         if(this[i] !== this[i]) flag = true;
     5         for(var j = i+1; j < this.length;){
     6             if(this[i] === this[j] ||(flag && this[j] !== this[j])){
     7                 this.splice(j,1);
     8             }else{
     9                 j++;
    10             }
    11         }
    12     }
    13     return this;
    14 }

转载于:https://www.cnblogs.com/Livia-Peng/p/array\_programming.html

[JavaScript]: http://www.cnblogs.com/Livia-Peng/p/js_Array.html