1.遞歸求和：

function sum(arr,n){
    return n==0?  0 : sum(arr,n-1)+arr[n-1];
}
var arr=[1,2,3];
var n=arr.length;
sum(arr,n);

2.for循環打印二維數組：

function printErarr(arr) {
    var row=arr.length;
    var col=arr[0].length;
    var printarr=[];
    for(var i=0;i<row;i++){
        for(var j=0;j<col;j++){
            printarr.push(arr[i][j]);
        }
    }
    return printarr;
}
var arr=[[1,2,3,4],[5,6,7,5],[2,4,56,8]];
printErarr(arr);

3.用遞歸判斷數組是否遞增：

結束條件：數組長度為1，返回true;
遞歸條件：如果最后一個大于倒數第二個，則再對倒數第二個與倒數第三個進行比較。

function isIncrese(arr,n) {
    if(n==1){return true;}
    return (arr[n-1]>=arr[n-2]) && isIncrese(arr,n-1);
}

var arr=[1,2,3,4];
var n=arr.length;
isIncrese(arr,n);

4.如何實現二分查找（數組有序，單調遞增）：（二分查找只對有序數據集有效）

1.將數組的第一個位置設置為start；
2.將數組的最后的位置設置為end；
3.只要end>=start，就進行循環：
mid值為end與start的中間值，判斷arr[mid]與findData的大?。?br> 如果<,則start為mid+1;
如果>，則end為mid-1;
如果=,則返回mid值即可。

   function binarySearch(arr,findData) {
        var n=arr.length;
        var start=0,end=n-1;
        while(end>=start){
           var mid=parseInt(start+(end-start)/2);
           if(arr[mid]<findData){
               start=mid+1;
           }
           else if(arr[mid]>findData){
               end=mid-1;
           }
           if(arr[mid]==findData){
               return mid;
           }
        }
        return -1;
    }
    var arr=[1,4,7,9,10];
    var findData=9;
    binarySearch(arr,findData);

5.如何在排序數組中，找出給定數字出現的次數：

在上述的二分查找中的找到的if語句中，將end,start均設為mid，
加入兩個循環：
向后循環，如果后面的數等于mid中的值，則將right+1;
向前循環，如果前面的數等于mid中的值，則將left+1;
最后返回end-start+1;

    function binaryNum(arr,dataNum) {
        var n=arr.length;
        var start=0,end=n-1;
        while(end>=start){
           var mid=parseInt(start+(end-start)/2);
           if(arr[mid]<dataNum){
               start=mid+1;
           }
           else if(arr[mid]>dataNum){
               end=mid-1;
           }
           if(arr[mid]==dataNum){
               var rightmid=mid+1;
               var leftmid=mid-1;
               end=mid;
               start=mid;
               while(arr[rightmid] && arr[rightmid]==dataNum){
                    end=mid+1;
                    rightmid+=1;
                }
               while(arr[leftmid] && arr[leftmid]==dataNum){
                    start=mid-1;
                    leftmid-=1;
                }
                return end-start+1;
           }
        }
        return -1;
    }
    var arr=[1,4,5,7,9,9,9,10];
    var dataNum=9;
    binaryNum(arr,dataNum);

6.如何計算兩個有序（遞增）整型數組的交集：

兩個循環對兩個數組進行嵌套循環。
如果>，則將arr2指針向后；
如果=，則判斷是否是第一次出現此數值，如果是，就將其加入新數組中，并跳出內部循環。如果不是，就跳出內部循環；
如果<，則跳出內部循環。

function mixed(arr1,arr2) {
    var n1=arr1.length;
    var n2=arr2.length;
    var findarr=[];
    for(var i=0;i<n1;i++){
        for(var j=0;j<n2;j++){
            if(arr1[i]>arr2[j]){
                continue;
            }
            if(arr1[i]==arr2[j]){
                if(arr1[i-1] && arr1[i]!=arr1[i-1]) {
                    findarr.push(arr1[i]);
                }
                break;
            }
            else {
                break;
            }
        }
    }
    return findarr
}
var arr1=[1,2,3,3,4,5];
var arr2=[3,4,5,6,7,8,9];
mixed(arr1,arr2);

7.如何找出數組中重復次數最多的數？

使用對象，key中存放值，value中存放次數。

   function GetMaxNum(arr) {
        var o={};
        var len=arr.length;
        var max=0;
        for(var i=0;i<len;i++){
            var name=arr[i];
            if(o[name]){
                o[name]+=1;
            }
            else{
                o[name]=1;
            }
        }
        for(var key in o){       //注意對對象的遍歷的寫法
            if(o[key]>max){
                max=o[key];
                console.log("次數最多為"+max+"次");
            }
        }
        for(var key in o){
            if(o[key]==max){
                console.log("值為："+key)
            }
        }
    }
    var arr=[1,1,1,2,2,3,4,4,4,7,7];
    GetMaxNum(arr);

8.如何在O(n)的事件復雜度內找出數組中出現次數超過了一半的數：

哈希法：如7中所示，創建一個hash_map，返回最大value的key值。

function findMost(arr) {
    var n=arr.length;
    var o={};
    var max=0;
    var num;
    for(var i=0;i<n;i++){
        var name=arr[i];
        if(o[name]){
            o[name]+=1;
        }
        else{
            o[name]=1;
        }
    }
    for(var key in o){
        if(o[key]>max){
           max=o[key];
           num=parseInt(key);
        }
    }
    return num;
}
var arr=[1,2,2,2,2,3];
findMost(arr);