一些算法

选择排序

function select(arr = [1, 2, 3]) {

    for (let i = 0; i < arr.length; i++) {

      let min = i;

      for (let j = i + 1; j < arr.length; j++) {

        if (arr[min] > arr[j]) {

          min = j;

        }

      }

      if (min !== i) {

        let temp = arr[i];

        arr[i] = arr[min];

        arr[min] = temp;

      }

    }

    return arr;

  }

 

快速排序

function quick(source) {

    let left=[];

    let right=[];

    let base=source[0]

    for(let i=1;i<source.length;i++){

      if(source[i]<base){

        left.push(source[i])

      }else{

        right.push(source[i])

      }

    }

    if(source.length<=1){

      return source

    }

    return quick(left).concat(base,quick(right))

  }

冒泡排序

function babel(arr = [19, 8, 15, 24, 45, 12, 5]) {

  

    for (let i = 0; i <= arr.length; i++) {

      let flag=false;

      for (let j= 0; j <= arr.length; j++) {

        if (arr[j] > arr[j + 1]) {

          const temp = arr[j];

          arr[j] = arr[j + 1];

          arr[j + 1] = temp;

          flag=true

        }

      }

      if(flag==false){

        break

      }

    }

    return arr

  }

归并排序

 function guibing(arr) {

    const middle = Math.ceil(arr.length / 2);

    if (arr.length < 2) {

      return arr;

    }

    return merge(guibing(arr.slice(0, middle)), guibing(arr.slice(middle)));

  }

 

  function merge(left, right) {

    let result = [];

    console.log(left, right);

    while (left.length && right.length) {

      if (left[0] <= right[0]) {

        result.push(left.shift());

      } else {

        result.push(right.shift());

      }

    }

    while (left.length) {

      result.push(left.shift());

    }

    while (right.length) {

      result.push(right.shift());

    }

 

    return result;

  }

二叉树

class Tree {

  constructor() {

    this.root = null;

  }

  insert(key) {

    key.forEach((key) => {

      const newnode = new Node(key);

      if (this.root === null) {

        this.root = newnode;

      }

      this.insertNode(this.root, newnode);

    });

  }

  insertNode(root, newnode) {

    if (newnode.key < root.key) {

      if (root.left === null) {

        root.left = newnode;

      } else {

        this.insertNode(root.left, newnode);

      }

    } else if (newnode.key > root.key) {

      if (root.right === null) {

        root.right = newnode;

      } else {

        this.insertNode(root.right, newnode);

      }

    }

  }

  inorderTraversal(callback) {

    this.inorderTraversalNode(this.root, callback);

  }

  inorderTraversalNode(node, callback) {

    if (node) {

      this.inorderTraversalNode(node.left, callback);

      callback(node);

      this.inorderTraversalNode(node.right, callback);

    }

  }

}