前端--算法聚集(2)

6、斐波那契數列

斐波那契數列，又稱黃金分割數列，指的是這樣一個數列：0、一、一、二、三、五、八、1三、2一、3四、5五、8九、.....在數學上，斐波那契數列主要考察遞歸的調用：

var getFibonacci = function(n){
　　var fibarr = [];
　　for(var i=0 ; i<n ;i++){
　　　　if(i<=1){
　　　　　　fibarr.push(i)
　　　　}else{
　　　　　　fibarr.push(fibarr[i-1] + fibarr[i-2])
　　　　}
　　}
　　return fibarr;
}

7、找出下列數組的最大差值

這是經過一道題目去測試對於基本的數組的最大值的查找，很明顯咱們知道，最大差值確定是一個數組中最大值與最小值的差：

var getMax = function(arr){
　　var maxNum = arr[0];
　　var minNum = arr[0];
　　for(var i=1 ; i<arr.length ; i++){
　　　　maxNum = (maxNum<arr[i]) ? arr[i] : maxNum;
　　　　minNum = (minNum<arr[i]) ? minNum : arr[i];
　　}
　　return maxNum-minNum

}

8、隨機生成指定長度的字符串

實現一個算法，隨機生成指定長度的字符串：

var randomString = function(n){
　　var str = 'abcdefghijklmnopqrstuvwxyz9876543210';
　　var len = str.length;
　　var strArr = "";
　　for(var i=0 ; i<n ; i++){
　　　　strArr+=str.charAt(Math.floor(Math.random()*len));
　　}
　　return strArr
}

9、使用JS 實現二叉查找樹(Binary Search Tree)

 

通常叫所有寫完的機率比較少，可是重點考察你對它的理解和一些基本特色的實現。 二叉查找樹，也稱二叉搜索樹、有序二叉樹（英語：ordered binary tree）是指一棵空樹或者具備下列性質的二叉樹：

• 任意節點的左子樹不空，則左子樹上全部結點的值均小於它的根結點的值；

• 任意節點的右子樹不空，則右子樹上全部結點的值均大於它的根結點的值；

• 任意節點的左、右子樹也分別爲二叉查找樹；

• 沒有鍵值相等的節點。二叉查找樹相比於其餘數據結構的優點在於查找、插入的時間複雜度較低。爲O(log n)。二叉查找樹是基礎性數據結構，用於構建更爲抽象的數據結構，如集合、multiset、關聯數組等。

 

       

 

     在寫的時候須要足夠理解二叉搜素樹的特色，須要先設定好每一個節點的數據結構

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;