1. 如何手寫一個JQ外掛?

方式一:
$.extend(src)  
該方法就是將src合併到JQ的全域性物件中去:
$.extend({
      log: ()=>{alert('撩課itLike');}
});

方式二:
$.fn.extend(src) 
該方法將src合併到jquery的例項物件中去:
 $.fn.extend({
       log: ()=>{alert('撩課itLike');}
 });
說說平衡二叉樹?
平衡二叉搜尋樹(Self-balancing binary search tree)
又被稱為AVL樹。

具有以下性質：

1
 
）它是一棵空樹或它的左右兩個子樹
的高度差的絕對值不超過1，
並且左右兩個子樹都是一棵平衡二叉樹。

2）平衡二叉樹必定是二叉搜尋樹，反之則不一定。

3）平衡二叉樹的常用實現方法有紅黑樹、AVL、
替罪羊樹、Treap、伸展樹等。 

最小二叉平衡樹的節點的公式如下：
F(n)=F(n-1)+F(n-2)+1 

備註：
1是根節點，
F(n-1)是左子樹的節點數量，
F(n-2)是右子樹的節點數量。

3. 清除浮動和解決垂直外邊距重疊的解決方案？

問題描述:
1) 父元素沒有設定寬高，尺寸由子元素撐起；
子元素一旦浮動，父元素高度會發生塌陷。
2）子元素設定margin-top會作用的父元素的margin-top;
此時會造成垂直外邊距重疊。
撩課小編：
.clearfix::after,
.clearfix::before{
      content: 
 
' '; 
      display: table;
      clear: both; 
}

4. sessionStorage 、localStorage 和 cookie ？

相同點:
都用於瀏覽器端儲存的快取資料;

不同點:
1) 儲存內容是否傳送到伺服器端

當設定了Cookie後，資料會發送到伺服器端，
造成一定的寬頻浪費；xxxstorage則會將資料儲存
到本地，不會造成寬頻浪費；

2) 資料儲存大小不同

Cookie資料不能超過4K，適用於會話標識；
xxxstorage資料儲存可以達到5M;

3) 資料儲存的有效期限不同

cookie只在設定了Cookid過期時間
之前一直有效，即使關閉視窗或者瀏覽器；

sessionStorage,僅在關閉瀏覽器之前有效；
localStorage,資料儲存永久有效；

 
4) 作用域不同
cookie和localStorage是在同源同窗口中
都是共享的；
sessionStorage不在不同的瀏覽器視窗
中共享，即使是同一個頁面；

5. 判斷一個單詞是否是迴文？

迴文是指把相同的詞彙或句子，
在下文中調換位置或顛倒過來，
產生首尾迴環的情景，
叫做迴文，也叫回環。
比如 cacac，redivider 。

let checkPalindrom = (str)=>{  
    return str === 
    str.split('').reverse().join('');
}

6. 不借助臨時變數，進行兩個整數的交換?

撩課小編：輸入 a = 3, b =1, 輸出 a = 1, b =3
let swap = (a , b)=>{  
  b = b - a;
  a = a + b;
  b = a - b;
  return [a,b];
}

7. 運用JS 實現二叉查詢樹？

二叉查詢樹，也稱二叉搜尋樹、有序二叉樹;
是指一棵空樹或者具有下列性質的二叉樹：
1) 任意節點的左子樹不空，
則左子樹上所有結點的值均
小於它的根結點的值；

2) 任意節點的右子樹不空，
則右子樹上所有結點的值
均大於它的根結點的值；

3) 任意節點的左、右子樹
也分別為二叉查詢樹；

4) 沒有鍵值相等的節點。

5) 二叉查詢樹相比於其他資料結構
的優勢在於查詢、插入的時間複雜度較低, 
為O(log n)。

二叉查詢樹是基礎性資料結構，
用於構建更為抽象的資料結構，
如集合、multiset、關聯陣列等。

實現：

1）先設定好每個節點的資料結構
class Node {  
  constructor(data, left, right) {
    this.data = data;
    this.left = left;
    this.right = right;
  }
}

2）樹是由節點構成，由根節點逐漸延生到各個子節點，
因此它具備基本的結構就是具備一個根節點，
具備新增，查詢和刪除節點的方法。

class BinarySearchTree  extend Node{
  constructor(data, left, right) {
      super(data, left, right);
      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) {
      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 = (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) {
    let 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;
  }
}