數字在排序數組中出現的次數

function GetNumberOfK(data, k)
{
    if(data.indexOf(k) == -1) return 0;
       var count = data.lastIndexOf(k)-data.indexOf(k);
    return count+1;
}

數組中只出現一次的數字

數組中出現次數超過一半的數字

連續子數組的最大和

從1-n中1出現的次數

二維數組中的查找

function Find(target, array)
{
    // write code here
   var i=0;
   var j=array[0].length-1;
    
 
while(j>=0 && i<array.length )
   if(target<array[i][j]){
       j--;
   }else if(target>array[i][j]){
       i++
   }else{
       return true;
   }
   

數組去重

排序算法總結

如何評價算法的優劣

1. 時間復雜度：一個算法執行所耗費的時間。
2. 空間復雜度: 運行完一個程序所需內存的大小。
3. 穩定性：排序後兩個相等的值的位置和排序之前的位置是否相同，如果相同就是穩定（不穩定的算法：快、選、堆、希）
4. 內/外排序：排毒操作是否需要額外空間

1.冒泡排序

基本原理：重復的走訪要排序的數組，每次比較兩個值，如果前者大於後者則交換兩者的位置。這樣最大的元素會慢慢浮到數組的末端

外層控制未排序數組的次數

內層控制未排序數組內兩欄比較的次數

function bubbleSort(arr){
    var len=arr.length;
    for (var i = 0; i < len; i++) {
        for (var j = 0; j < len-1-i; j++) {
            if (arr[j]>arr[j+1]) {
                var temp=arr[j+1];
                arr[j
 
+1]=arr[j];
                arr[j]=temp;
            }
        }
    }
    return arr;
}

2.選擇排序

基本原理：每次找出數組中最小元素的位置，然後和未排序數組的第一個值進行交換

function selectSort(arr){
    var len=arr.length,
        minIndex;

    for (var i = 0; i < len-1; i++) {
        minIndex=i;
        for (var j = i+1; j <len; j++) {
            if (arr[j]<arr[minIndex]) {
                minIndex=j;
            }
        }

        var temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
    }
    return arr;
}

數組中重復的數字

構建乘機數組

關於數組的算法題