前端--算法汇集(2)

六、斐波那契数列

斐波那契数列，又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、55、89、.....在数学上，斐波那契数列主要考察递归的调用：

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;
}

七、找出下列数组的最大差值

这是通过一道题目去测试对于基本的数组的最大值的查找，很明显我们知道，最大差值肯定是一个数组中最大值与最小值的差：

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

}

八、随机生成指定长度的字符串

实现一个算法，随机生成指定长度的字符串：

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
}

九、使用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;

转载于:https://www.cnblogs.com/leong-min/p/6101885.html