摘要：重點(diǎn)是檢測(cè)到空格時(shí)進(jìn)行處理。使用實(shí)現(xiàn)二叉查找樹一般叫全部寫完的概率比較少，但是重點(diǎn)考察你對(duì)它的理解和一些基本特點(diǎn)的實(shí)現(xiàn)。二叉查找樹相比于其他數(shù)據(jù)結(jié)構(gòu)的優(yōu)勢(shì)在于查找插入的時(shí)間復(fù)雜度較低。統(tǒng)計(jì)數(shù)組中每個(gè)元素及出現(xiàn)的次數(shù)，并輸出到頁(yè)面

實(shí)現(xiàn)一個(gè)函數(shù)clone，可以對(duì)JavaScript中的5種主要的數(shù)據(jù)類型（包括Number、String、Object、Array、Boolean）進(jìn)行值復(fù)制

    function clone(obj){
        var result;
        switch(typeof obj){
            case "undefined":
            break;
            case "string":
            result = obj+"";
            break;
            case "number":
            result = obj-0;
            break;
            case "boolean":
            result =obj;
            break;
            case "object":
                if(obj ===null){
                    result = null;
                } else {
                    if(Object.prototype.toString.call(obj).slice(8,-1)==="Array"){
                        result=[];
                        for(var i=0;i
判斷一個(gè)單詞是否是回文
回文是指把相同的詞匯或句子，在下文中調(diào)換位置或顛倒過來，產(chǎn)生首尾回環(huán)的情趣，叫做回文，也叫回環(huán)。
很多人拿到這樣的題目非常容易想到用for將字符串顛倒字母順序然后匹配就行了。其實(shí)重要的考察的是對(duì)于reverse的實(shí)現(xiàn)。其實(shí)我們可以利用現(xiàn)成的函數(shù)，將字符串轉(zhuǎn)換成數(shù)組，這個(gè)思路很重要，我們可以擁有更多的自由度去進(jìn)行字符串的一些操作。
let reverseStr = function(str) {  
    return str = str.split("").reverse().join("");
}
reverseStr("abcdefg");
//gfedcba
在句子中反轉(zhuǎn)詞
如fix this one 變?yōu)?one this fix。重點(diǎn)是檢測(cè)到空格時(shí)進(jìn)行處理。
    function reverseWord(str){
        return str.split(" ").reverse().join(" ")
    }
反轉(zhuǎn)每個(gè)單詞中字符的順序
“I am the good boy” 反轉(zhuǎn)成這樣 “I ma eht doog yob”
    function reverse(str){
        return str.split(" ").reverse().join(" ").split("").reverse().join("");
    }

去掉一組整型數(shù)組重復(fù)的值
題目如下輸入: [3,13,24,11,11,14,1,2]
   輸出: [3,13,24,11,14,2]
   需要去掉重復(fù)的11 和 1 這兩個(gè)元素。

這道題有多重方法，我理解的主要是考察個(gè)人對(duì)Object的使用，利用key來進(jìn)行篩選。
    function unique(arr) {  
        let hashTable = {};
        let data = [];
        for(let i=0,l=arr.length;i
再來一個(gè)其他實(shí)現(xiàn)方式，這個(gè)方法常在我的項(xiàng)目中出現(xiàn)，用的時(shí)候確實(shí)覺得代碼少了那么幾行
     function unique(arr) {  
        let data = [];
        for(let i=0,l=arr.length;i
統(tǒng)計(jì)一個(gè)字符串出現(xiàn)最多的字母
輸入一段英文連續(xù)的英文字符串 afjghdfraaaasdenas，找出重復(fù)出現(xiàn)次數(shù)最多的字母
    function findMaxChar(str) {  
          if(str.length == 1) {
            return str;
          }
          let charObj = {};
          for(let i=0;i= maxValue) {
              maxChar = k;
              maxValue = charObj[k];
            }
         }
         return maxChar;
     }
     findMaxChar("afjghdfraaaasdenas")
    //a
找到字符串中的第一個(gè)非重復(fù)的字符
遍歷字符串，用一個(gè)對(duì)象當(dāng)做hash表來存儲(chǔ)重復(fù)字符。
    function firstNonRepeatChar(str){
        var count = {};
        for(var i=0;i
刪除字符串中重復(fù)的字符
其實(shí)是在上一個(gè)問題的基礎(chǔ)上再進(jìn)行操作：
    function firstNonRepeatChar(str){
        var count = {};
        var result = [];
        for(var i=0;i
在n和m之間生成隨機(jī)整數(shù)
    Math.floor(Math.random()*(m-n))+n
排序算法(冒泡排序)
冒泡排序JavaScript代碼實(shí)現(xiàn)：
    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]) {        //相鄰元素兩兩對(duì)比
                    var temp = arr[j+1];        //元素交換
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
    bubbleSort([3,5,2,8,9,7,6])
    //[2, 3, 5, 6, 7, 8, 9]
排序算法（選擇排序）
在時(shí)間復(fù)雜度上表現(xiàn)最穩(wěn)定的排序算法之一，因?yàn)闊o論什么數(shù)據(jù)進(jìn)去都是O(n2)的時(shí)間復(fù)雜度。。。所以用到它的時(shí)候，數(shù)據(jù)規(guī)模越小越好。唯一的好處可能就是不占用額外的內(nèi)存空間了吧。
    function selectionSort(arr) {
        var len = arr.length;
        var minIndex, temp;
        for (var i = 0; i < len - 1; i++) {
            minIndex = i;
            for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {     //尋找最小的數(shù)
                    minIndex = j;                 //將最小數(shù)的索引保存
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }
     selectionSort([3,5,2,8,9,7,6])
    //[2, 3, 5, 6, 7, 8, 9]
從未排序的整數(shù)數(shù)組中找出缺失的數(shù)字
比如你有1到100的整數(shù)，而其中缺了一個(gè)，怎么找出這個(gè)數(shù)字？利用等差數(shù)列公式計(jì)算這些數(shù)應(yīng)得的和，再計(jì)算當(dāng)前數(shù)組所有數(shù)字的和，二者的差即為缺少的數(shù)。
    function missingNumber(arr){
        var n = arr.length+1;
        var expectedSum = (1+n)*n/2;
        var sum = 0;
        for(var i=0;i
檢查是否有任何兩個(gè)數(shù)字的和是給定的數(shù)字
最暴力的方法就是兩層循環(huán)，是O(n2).改進(jìn)方法使用一個(gè)對(duì)象作為哈希表，用于存儲(chǔ)數(shù)，這樣在每次搜尋是否有另一個(gè)數(shù)與當(dāng)前數(shù)的和為sum時(shí)就可以在O(1)的時(shí)間內(nèi)找到。
    function twoSum(arr,sum){
        var obj = {};
        var num;
        for(var i=0;i
檢查是否有任何兩個(gè)數(shù)字的和是給定的數(shù)字,有的話將數(shù)字和位置以對(duì)象的方式返回值，否則返回false
最暴力的方法就是兩層循環(huán)，是O(n2).改進(jìn)方法使用一個(gè)對(duì)象作為哈希表，用于存儲(chǔ)數(shù)，這樣在每次搜尋是否有另一個(gè)數(shù)與當(dāng)前數(shù)的和為sum時(shí)就可以在O(1)的時(shí)間內(nèi)找到。
    function twoSum(arr,sum){
        var obj = {};
        var num;
        for(var i=0;i
找到任意兩個(gè)數(shù)字的最大和
找到兩個(gè)最大的數(shù)并返回它們的和。
    function topSum(arr){
        if(arr.length<2) return null;
        var first,second;
        if(arr[0]>arr[1]){
            first = arr[0];
            second=arr[1];
        }else{
            first = arr[1];
            second=arr[0];
        }
    
        for(var i=2;ifirst){
                second = first;
                first = arr[i];
            }else if(arr[i]>second){
                second = arr[i];
            }
        }
    
        return first+second;
    }
從1到n中0的總個(gè)數(shù)
n=50的話，有5個(gè)0，分別是10，20，30，40，50。 
n = 120的話，分別是10到90，共九個(gè)，110到120，共2個(gè)，以及100的兩個(gè)，一共13個(gè)。 
也就是說10的整數(shù)次方會(huì)有多個(gè)零，如100，1000，那么就要利用現(xiàn)有的數(shù)計(jì)算包含了多少個(gè)10的平方數(shù)。
如2014，2014/10=201; 201/10 = 20; 20/10 = 2; 最后表明出現(xiàn)了兩次10的三次方，即1000和2000。
    function countZero(n){
        var count = 0;
        while(n>0){
            count+=Math.floor(n/10);
            n/=10;
        }
        return count;
    }
匹配字符串的子字符串
    function substr(str,subStr){
        for(var i=0;i
字符串的全排列
    var result = [];
    function permutations(str){
        var arr= str.split("");
    
        helper(arr,0,[]);
        return result;
    }
    function helper(arr,index,list){
        if(index === arr.length){
            result.push(list.join(""));
            return;
        }
        for(var i = 0;i
不借助臨時(shí)變量，進(jìn)行兩個(gè)整數(shù)的交換
把 a = 2, b = 4 變成 a = 4, b =2
這種問題非常巧妙，需要大家跳出慣有的思維，利用 a , b進(jìn)行置換
主要是利用 + – 去進(jìn)行運(yùn)算，類似 a = a + ( b – a) 實(shí)際上等同于最后 的 a = b;
    function swap(a , b) {  
      b = b - a;
      a = a + b;
      b = a - b;
      console.log("a="+a);
      console.log("b="+b)
    }
    var a=2,b=4;
    swap(a,b)
    //a=4;b=2
斐波那契數(shù)列(黃金分割數(shù)列)不說換金分割我也不知道是啥玩意兒啦
斐波那契數(shù)列，又稱黃金分割數(shù)列，指的是這樣一個(gè)數(shù)列：0、1、1、2、3、5、8、13、21、34、……在數(shù)學(xué)上，斐波納契數(shù)列主要考察遞歸的調(diào)用。
    function getFibonacci(n) {  
      var fibarr = [];
      var i = 0;
      while(i
獲得第n個(gè)斐波那契數(shù)字
解法一：迭代
var fibonacci = function(n){
    var fibo = [0,1];
    for(var i=2;i<=n;i++){
        fibo[i] = fibo[i-1]+fibo[i-2];
    }
    return fibo[n];
}

解法二：遞歸
    var fibonacci = function(n){
        if(n>=2){
            return fibonacci(n-1)+fibonacci(n-2);
        }else{
            return n;
        }
    }
找到兩個(gè)數(shù)的最大公約數(shù)
解法一：遍歷
    var greatestCommonDivisor= function(a,b){
        if(a<2 || b<2) return 1;
        var divider = 2;
        var greatestDivisor = 1;
        while(divider<=a && divider<=b){
            if(a%divider == 0 && b%divider == 0){
                greatestDivisor = divider;
            }
            divider++;
        }
        return greatestDivisor;
    }
解法二：輾轉(zhuǎn)相除法
又名歐幾里德算法（Euclidean algorithm）乃求兩個(gè)正整數(shù)之最大公因子的算法。它是已知最古老的算法……
有解釋的，但我選擇不去理解……
    function greatestCommonDivisor(a, b){
       if(b == 0)
         return a;
       else 
         return greatestCommonDivisor(b, a%b);
    }
合并兩個(gè)排序數(shù)組
var mergeSortedArray = function(a,b){
    var merge = [];
    var i = 0,j = 0;
    var k = 0;
    while(ib[j])){
            merge[k++] = b[j++];
        }else{
            merge[k++] = a[i++];
        }
    }
    return merge; 
}
驗(yàn)證一個(gè)數(shù)是否是質(zhì)數(shù)
質(zhì)數(shù)只能被1和它自己整除，因此令被除數(shù)從2開始，若能整除則不是質(zhì)數(shù)，若不能整除則加一，直到被除數(shù)到達(dá)根號(hào)n，此時(shí)n則是質(zhì)數(shù)。
    function isPrime(n){
        var divider = 2;
        var limit = Math.sqrt(n);
        while(divider<=limit){
            if(n%divider == 0){
                return false;
            }
            divider++;
        }
        return true;
    }
    isPrime(3);
    //true
查找數(shù)字的所有質(zhì)數(shù)因子
divider從2開始,如果n能整除divider，則將divider加入到結(jié)果中，n為此次計(jì)算后的商,如果n不能整除divider，則divider++
var primeFactors = function(n){
    var factors = [];
    var divider = 2;
    while(n>2){
        if(n%divider == 0){
            factors.push(divider);
            n /= divider;
        }else{
            divider++;
        }
    }
    return factors;
}
找出正數(shù)組的最大差值比
這是通過一道題目去測(cè)試對(duì)于基本的數(shù)組的最大值和最小值的查找
     function getMaxProfit(arr) {
        var minPrice = arr[0];
        var maxProfit = 0;
        for (var i = 0; i < arr.length; i++) {
            var currentPrice = arr[i];
            minPrice = Math.min(minPrice, currentPrice);
            var potentialProfit = currentPrice - minPrice;
            maxProfit = Math.max(maxProfit, potentialProfit);
        }
        return maxProfit;
    }
    getMaxProfit([10,5,11,7,8,9])
    //6
隨機(jī)生成指定長(zhǎng)度的字符串
    function randomString(n) {  
      let str = "abcdefghijklmnopqrstuvwxyz9876543210";
      let tmp = "",
          i = 0,
          l = str.length;
      for (i = 0; i < n; i++) {
        tmp += str.charAt(Math.floor(Math.random() * l));
      }
      return tmp;
    }
    randomString(9);  //指定長(zhǎng)度為9
    //4ldkfg9j7
實(shí)現(xiàn)類似getElementsByClassName 的功能
自己實(shí)現(xiàn)一個(gè)函數(shù)，查找某個(gè)DOM節(jié)點(diǎn)下面的包含某個(gè)class的所有DOM節(jié)點(diǎn)？不允許使用原生提供的 getElementsByClassName querySelectorAll 等原生提供DOM查找函數(shù)。
    function queryClassName(node, name) {  
      var starts = "(^|[ 

	f])",
           ends = "([ 

	f]|$)";
      var array = [],
            regex = new RegExp(starts + name + ends),
            elements = node.getElementsByTagName("*"),
            length = elements.length,
            i = 0,
            element;
     
        while (i < length) {
            element = elements[i];
            if (regex.test(element.className)) {
                array.push(element);
            }
     
            i += 1;
        }
     
        return array;
    }
    queryClassName()
使用JS 實(shí)現(xiàn)二叉查找樹
一般叫全部寫完的概率比較少，但是重點(diǎn)考察你對(duì)它的理解和一些基本特點(diǎn)的實(shí)現(xiàn)。 二叉查找樹，也稱二叉搜索樹、有序二叉樹（英語：ordered binary tree）是指一棵空樹或者具有下列性質(zhì)的二叉樹：
任意節(jié)點(diǎn)的左子樹不空，則左子樹上所有結(jié)點(diǎn)的值均小于它的根結(jié)點(diǎn)的值；
任意節(jié)點(diǎn)的右子樹不空，則右子樹上所有結(jié)點(diǎn)的值均大于它的根結(jié)點(diǎn)的值； 任意節(jié)點(diǎn)的左、右子樹也分別為二叉查找樹；
沒有鍵值相等的節(jié)點(diǎn)。二叉查找樹相比于其他數(shù)據(jù)結(jié)構(gòu)的優(yōu)勢(shì)在于查找、插入的時(shí)間復(fù)雜度較低。為O(log
n)。二叉查找樹是基礎(chǔ)性數(shù)據(jù)結(jié)構(gòu)，用于構(gòu)建更為抽象的數(shù)據(jù)結(jié)構(gòu)，如集合、multiset、關(guān)聯(lián)數(shù)組等。
    class Node {  
      constructor(data, left, right) {
        this.data = data;
        this.left = left;
        this.right = right;
      }
    }
    
    class BinarySearchTree {
      constructor() {
        this.root = null;
      }
      insert(data) {
        let n = new Node(data, null, null);
        if (!this.root) {
          return this.root = n;
        }
        let currentNode = this.root;
        let parent = null;
        while (1) {
          parent = currentNode;
          if (data < currentNode.data) {
            currentNode = currentNode.left;
            if (currentNode === null) {
              parent.left = n;
              break;
            }
          } else {
            currentNode = currentNode.right;
            if (currentNode === null) {
              parent.right = n;
              break;
            }
          }
        }
      }
     
      remove(data) {
        this.root = this.removeNode(this.root, data)
      }
     
      removeNode(node, data) {
        if (node == null) {
          return null;
        }
        if (data == node.data) {
          // no children node
          if (node.left == null && node.right == null) {
            return null;
          }
          if (node.left == null) {
            return node.right;
          }
          if (node.right == null) {
            return node.left;
          }
          let getSmallest = function(node) {
            if(node.left === null && node.right == null) {
              return node;
            }
            if(node.left != null) {
              return node.left;
            }
            if(node.right !== null) {
              return getSmallest(node.right);
            }
          }
          let temNode = getSmallest(node.right);
          node.data = temNode.data;
          node.right = this.removeNode(temNode.right,temNode.data);
          return node;
        } else if (data < node.data) {
          node.left = this.removeNode(node.left,data);
          return node;
        } else {
          node.right = this.removeNode(node.right,data);
          return node;
        }
      }
     
      find(data) {
        var current = this.root;
        while (current != null) {
          if (data == current.data) {
            break;
          }
          if (data < current.data) {
            current = current.left;
          } else {
            current = current.right
          }
        }
        return current.data;
      }
     
    }
     
    module.exports = BinarySearchTree;
統(tǒng)計(jì)數(shù)組中每個(gè)元素及出現(xiàn)的次數(shù)，并輸出到頁(yè)面
  function getArrayMess(arr) {  
          if(arr.length == 1) {
            console.log("{"+arr[0]+":1")
          }
          let charObj = {};
          for(let i=0;i