面試時常遇到的數組面試題

1.計算給定數組 arr 中所有元素的總和

function add(arr){
var result=0;
for(var i = 0,item;item=arr[i++];){
result+=item;
}
return result;
}
var arr=[1,2,3,4,5];
console.log(add(arr))

 

2.合並數組 arr1 和數組 arr2。不要直接修改數組 arr，結果返回新的數組

function mix(arr1,arr2){

var arr3=[];

return arr3.concat(arr1,arr2);
}
console.log(mix([1,2,3],[2,3,4,5]))

 

3：刪除數組 arr 第一個元素。不要直接修改數組 arr，結果返回新的數組

function deleteArr(arr){
var a=arr.slice(0);
b=a.splice(0,1);//a.shift()
return a

}
console.log(deleteArr([1,2,3,4,5]))

 

4：在數組 arr 開頭添加元素 item。不要直接修改數組 arr，結果返回新的數組

function addArr(arr,item){
var a= arr.slice(0);
b=a.splice(0,0,item);//a.unshift(item)
return a;
}
console.log(addArr([1,2,3,4],5))

 

5：移除數組 arr 中的所有值與 item 相等的元素，直接在給定的 arr 數組上進行操作，並將結果返回

function turnBack(arr,item){
for (var i = arr.length - 1; i >= 0; i--) {
if(arr[i]==item){
arr.splice(i,1);
}

}
return arr
}

console.log(turnBack([1,2,3,3,4,5,3,6],3))

（二）

 var arr=[1,1,1,2,2,1,3,1,3,4,5,6];

    function arrDel(arr){

      var result=[],

             obj={};

          for(var i in arr){

           if(!obj[arr[i]]){ //判斷對象的屬性

               result.push(arr[i]);

                  obj[arr[i]]=1;

           }

          }

          return result;

    }



    console.log(arrDel(arr));

 （三）

function uniq(arr){
    var result = [];
    var flag = true;
    for(var i=0;i<arr.length;i++){
        for(var j=0;j<result.length;j++){
            if(arr[i]===result[j]){
                flag = false;
            }   
        }
        if(flag){
            result.push(arr[i]);
        }
    }
    return result;
}

（四）

function uniq(arr){
    return arr.filter(function(item,index,array){
        return array.indexOf(item) === index;
    });
}
uniq([1,2,1,1,4])
// [1, 2, 4]

（五）

function sortAndUniq(arr){
    return arr.sort().filter(function(item,index,array){
        return item !== array[index+1];
    });
}
sortAndUniq([1,2,1,1,4])
// [1, 2, 4]

（六）

var arr=[1,1,1,2,2,1,3,1,3,4,5,6];
    var set = new Set(arr);
    var newSet =Array.from(set);

    console.log(newSet) //1,2,3,4,5,6

set()方法是ES6的新特性，部分瀏覽器支持

 

6：找出元素 item 在給定數組 arr 中的位置

//直接console.log([1,2,3,4,5].indexOf(2))

function indexOf(arr,item){
for (var i = arr.length - 1; i >= 0; i--) {
if(arr[i]==item){
return i;
}
}
return -1;
}
console.log(indexOf([1,2,3,4,5,6],3));

 

7.判斷一個數組中出現次數最多的元素，統計這個次數

function maxCountElement(arr) {  
   var obj={};
   for(var i=0;i<arr.length;i++){  
       var key=arr[i];  
       if(obj[key]){
           obj[key]++;  
       }else{  
           obj[key]=1;
       }  
   }  
 
   var maxCount=0;
   var maxElement=arr[0];
   for(var key in obj){  
       if(maxCount<obj[key]){  
           maxCount=obj[key]; 
           maxElement=key;  
       }  
   }  
   return "該數組中出現次數最多的元素:"+maxElement+"出現了"+maxCount+"次";  
    }  

 

注： 上面的代碼有一點小的瑕疵，如果數組中兩個不同的元素出現的次數一樣多，結果只會體現第一次遇見的次數最多的                   元素，和它次數一樣多的其他元素會被忽略掉。

 

改進方案代碼如下：

function maxCountElement(arr) {  
   var obj={};
   for(var i=0;i<arr.length;i++){  
       var key=arr[i];  
       if(obj[key]){
           obj[key]++;  
       }else{  
           obj[key]=1;
       }  
   }  
 
   var maxCount=0;
   var maxElement=arr[0];
   var eq = [];
   for(var key in obj){  
       if(maxCount < obj[key]){  
           maxCount=obj[key]; 
           maxElement=key;  
           eq.length=0;
       }else if(maxCount === obj[key]){  
           eq.push(key);
       }
   }  
   if(eq.length > 0){
       for(var j=0;j<eq.length;j++){
       maxElement+='，'+eq[j];
       }
   }
   return "該數組中出現次數最多的元素:"+maxElement+"-----出現了:"+maxCount+"次";  
    }  

    var arr = [1,2,2,3,3,4,5,6];
    var res = maxCountElement(arr);

    console.log(res);

8.計算數組中每個元素出現的次數

var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
 
var countedNames = names.reduce(function (allNames, name) { 
  if (name in allNames) {
    allNames[name]++;
  }
  else {
    allNames[name] = 1;
  }
  return allNames;
}, {});
// countedNames is:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }

同上類似：判斷一個字符串中出現次數最多的字母：

function maxCount(str) {  
   var obj={};
   for(var i=0;i<str.length;i++){  
       var key=str[i];  
       if(obj[key]){
           obj[key]++;  
       }else{  
           obj[key]=1;
       }  
   }  
 
   var maxCount=0;
   var maxString="";
   for(var key in obj){  
       if(maxCount<obj[key]){  
           maxCount=obj[key]; 
           maxString=key;  
       }  
   }  
   return "出現次數最多的字母:"+maxString+"出現了"+maxCount+"次";  

    }  

(二)

 var json={}; //定義對象來存放 對象屬性的值



   //遍歷字符串，將重復出現的字符 累加

   for(var i=0;i<str.length;i++){

     if(!json[str.charAt(i)]){

            json[str.charAt(i)]=1;

     }else{

         json[str.charAt(i)]++;

     }

   }



   var iMax=0;

   var icur='';

   console.log(json);//{a:3,d:8,f:7,s:6,j:1}



   //遍歷 json對象取最大值

   for(var val in json){

     if(json[val]>iMax){

        iMax=json[val];

           icur=val;

     }

   }



   console.log('出現最多的字符:'+icur,'出現次數:'+iMax);       

 

9.冒泡排序

var arr= [12,34,56,23,4,74,2,33,21,54,19,13,14,16,50]
        function buttleSort (arr) {
            var len= arr.length;
            var  i = 0;
            for (; i < len;i++) {//遞歸循環
                for (var j=0; j<len-i;j++) {
                    if (arr[j]>arr[j+1]) {
                        //交換位置
                        var term=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=term;
                    }
                }
            }
            return arr
        }
        console.log(buttleSort (arr));

• （1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個位置。
• （2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
• （3）針對所有的元素重復以上的步驟，除了最后一個。
• （4）持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

10.快速排序

var array = [1,4,-8,-3,6,12,9,8];
function quickSort(arr){
//如果數組長度小於等於1，則返回數組本身
    if(arr.length<=1){
        return arr;
    }
    //定義中間值的索引
    var index = Math.floor(arr.length/2);
    //取到中間值
    var temp = arr.splice(index,1);
    //定義左右部分數組
    var left = [];
    var right = [];
    for(var i=0;i<arr.length;i++){
    //如果元素比中間值小，那么放在左邊，否則放右邊
        if(arr[i]<temp){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat(temp,quickSort(right));
}
document.write(quickSort(array));
//遞歸思想，兩邊快速的排序，冒泡排序的改進

Math.floor(x)方法是向下取整，返回小於或等於x的最接近的整數。

splice(index,num,item)方法是向數組中添加項目，或是從數組中刪除項目，並返回被刪除的項目。

• index是整數，被操作項目所在的位置（必須）
• num是整數，要刪除的項目的數量，如果為0，表示不刪除（必須）
• item是向數組中添加的新項目，可以是多個（可選）

push()方法是向數組末尾添加一個或多個新項目並返回新數組的長度

concat()方法連接兩個或多個數組，不會改變原有數組，返回一個新數組

 11.插入排序

var array = [1,4,-8,-3,6,12,9,8];
function insertSort(arr){
//假設第0元素是有序序列，第1元素之后是無序的序列。從第1元素開始依次將無序序列的元素插入到有序序列中
    for(var i=1; i<arr.length;i++){
        if(arr[i]<arr[i-1]){
            //取出無序序列中需要插入的第i個元素
            var temp = arr[i];
            //定義有序中的最后一個位置
            var j = i-1;
            arr[i] = arr[j];
            //比較大小，找到插入的位置
            while(j>=0&&temp<arr[j]){
                arr[j+1] = arr[j];
                j--;
            };
            //插入
            arr[j+1] = temp;
        }
    }
  }
insertSort(array)
document.write(array);
（1）從第一個元素開始，該元素可以認為已經被排序
（2）取出下一個元素，在已經排序的元素序列中掃描
（3）如果該元素（已排序）大於新元素，將該元素移到下一位置
（4）重復步驟3，直到找到已排序的元素小於或者等於新元素的位置
（5）將新元素插入到下一位置中
（6）重復步驟2

 

12. 選擇排序

var array = [1,4,-8,-3,6,12,9,8];
function selectSort(arr){
    for(var i=0;i<arr.length;i++){
        //設置當前范圍最小值和索引
        var min = arr[i];
        var minIndex = i;
        //在該范圍選出最小值
        for(var j=i+1;j<arr.length;j++){
            if(min>arr[j]){
                min = arr[j];
                minIndex = j;
            }
        }
        //將最小值插入,並將原來位置的最小值刪除
        arr.splice(i,0,min);
        arr.splice(minIndex+1,1);
    }
}
selectSort(array);
document.write(array);
（1）在未排序序列中找到最小（大）元素
（2）並存放到排序序列的起始位置
（3）然后，再從剩余未排序元素中繼續尋找最小（大）元素
（4）然后放到已排序序列的末尾。
（5）以此類推

13.尋找兩個有序數組最小相同元素

const a = [1, 2, 5, 9, 10]
const b = [3, 4, 6, 9, 10]

function findElement (a, b) {
    let i = j = 0
    while (i < a.length || j < b.length) {
        if (a[i] === b[j]) {
            return a[i]
        } else if (a[i] > b[j]) {
            j ++
        } else if (a[i] < b[j]) {
            i ++
        }
    }
    return null
}

console.log(findElement(a, b))
// => 9