质数（素数）: 在大于1的自然数中只能被1和自己整除

1. 判断一个数是不是质数，
   基本思路：对正整数n，如果用2到√n之间的所有整数去除，均无法整除，则n为质数

     function isPrimeNumber(num){
        num = Number(num);
        if(isNaN(num) || num <= 0){
           return false;
        }  
        let _tmp = 2;
        let  limit = Math.sqrt(num);
        while(_tmp <= limit ){
           if(num%_tmp === 0 ){
               return false;
          }  
          _tmp ++;
        }
        return true;
     }
   

2. 查找数字的所有质数因子
   基本思路：num能整除质数因子，能整除加入到结果中，num为此次计算后的商; 不能++

     function getPrimeFactors (num) {
      let factors = [];
      let _tmp = 2;
      while (num > 2) {
        if (n%_tmp === 0) {
            factors.push(_tmp);
            n /= _tmp;
        } else {
            _tmp++;
        }
      }
      return factors;
    }
   

公约数： 几个整数中公有的约数，叫做这几个数的[公约数]；其中最大的一个，叫做这几个数的[最大公约数]

1. 欧几里德算法算两个数的最大公约数
   基本思路: 先求出其中任意两个数的最大公约数，再求这个最大公约数与第三个数的最大公约数，依次求下去，直到最后一个数为止。最后所得的那个最大公约数，就是所有这些数的最大公约数

   function getGCD (a, b) {
     if ( b == 0 ) {
       return a;   
     } else {
       getGCD(b, a%b);
     }
   }

斐波那契数列: 后一个数等于前面两个数的和 1,1,2,3,5,8,13.21...

1. 求第n个斐波那契数字
   思路：Fn = Fn-1 + Fn-2， n > 2, 递归

      function getFibonacci(n){
         if (n === 1 || n === 2 ) {
           return 1;
         } else {
           return getFibonacci(n-1) + getFibonacci(n-2)
         }
      }
   

排序

1. 冒泡排序
   思路：将相邻两个数进行比较， 如果大交换位置，对每一个数进行同样的操作， 直到没有任何数可以进行比较

   function bubbleSort (arr) {
        let limit = arr.length;
        let index, second;
        for(index = 0; index < limit; index++){
           for(second = index+1; second < limit; second++){
              if (arr[index] > arr[second]) {
                 let _tmp = arr[index];
                 arr[index] = arr[second];
                 arr[second] = _tmp;
             }
          }
       }
      return arr;    
   }