function bubbleSort(arr) {
    if (!Array.isArray(arr) || arr.length <= 1) return;
    let lastIndex = arr.length - 1;
    while (lastIndex > 0) { // 当最后一个交换的元素为第一个时，说明后面全部排序完毕
        let flag = true, k = lastIndex;
        for (let j = 0; j < k; j++) {
            if (arr[j] > arr[j + 1]) {
                flag = false;
              	lastIndex = j; // 设置最后一次交换元素的位置
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
      	if (flag) break;
    }
}

function selectSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  for (let i = 0; i < length - 1; i++) {

    let minIndex = i; // 设置当前循环最小元素索引

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

      // 如果当前元素比最小元素索引，则更新最小元素索引
      if (array[minIndex] > array[j]) {
        minIndex = j;
      }
    }

    // 交换最小元素到当前位置
    // [array[i], array[minIndex]] = [array[minIndex], array[i]];
    swap(array, i, minIndex);
  }

  return array;
}

// 交换数组中两个元素的位置
function swap(array, left, right) {
  var temp = array[left];
  array[left] = array[right];
  array[right] = temp;
}

function insertSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  // 循环从 1 开始，0 位置为默认的已排序的序列
  for (let i = 1; i < length; i++) {
    let temp = array[i]; // 保存当前需要排序的元素
    let j = i;

    // 在当前已排序序列中比较，如果比需要排序的元素大，就依次往后移动位置
    while (j -1 >= 0 && array[j - 1] > temp) {
      array[j] = array[j - 1];
      j--;
    }

    // 将找到的位置插入元素
    array[j] = temp;
  }

  return array;
}

function hillSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;


  // 第一层确定增量的大小，每次增量的大小减半
  for (let gap = parseInt(length >> 1); gap >= 1; gap = parseInt(gap >> 1)) {

    // 对每个分组使用插入排序，相当于将插入排序的1换成了 n
    for (let i = gap; i < length; i++) {
      let temp = array[i];
      let j = i;

      while (j - gap >= 0 && array[j - gap] > temp) {
        array[j] = array[j - gap];
        j -= gap;
      }
      array[j] = temp;
    }
  }

  return array;
}

function mergeSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于0，直接返回，不需要排序 
  if (!Array.isArray(array) || length === 0) return;

  if (length === 1) {
    return array;
  }

  let mid = parseInt(length >> 1), // 找到中间索引值
    left = array.slice(0, mid), // 截取左半部分
    right = array.slice(mid, length); // 截取右半部分

  return merge(mergeSort(left), mergeSort(right)); // 递归分解后，进行排序合并
}


function merge(leftArray, rightArray) {

  let result = [],
    leftLength = leftArray.length,
    rightLength = rightArray.length,
    il = 0,
    ir = 0;

  // 左右两个数组的元素依次比较，将较小的元素加入结果数组中，直到其中一个数组的元素全部加入完则停止
  while (il < leftLength && ir < rightLength) {
    if (leftArray[il] < rightArray[ir]) {
      result.push(leftArray[il++]);
    } else {
      result.push(rightArray[ir++]);
    }
  }

  // 如果是左边数组还有剩余，则把剩余的元素全部加入到结果数组中。
  while (il < leftLength) {
    result.push(leftArray[il++]);
  }

  // 如果是右边数组还有剩余，则把剩余的元素全部加入到结果数组中。
  while (ir < rightLength) {
    result.push(rightArray[ir++]);
  }

  return result;
}

function quickSort(array, start, end) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1 || start >= end) return;

  let index = partition(array, start, end); // 将数组划分为两部分，并返回右部分的第一个元素的索引值

  quickSort(array, start, index - 1); // 递归排序左半部分
  quickSort(array, index + 1, end); // 递归排序右半部分
}


function partition(array, start, end) {

  let pivot = array[start]; // 取第一个值为枢纽值，获取枢纽值的大小


  // 当 start 等于 end 指针时结束循环
  while (start < end) {

    // 当 end 指针指向的值大等于枢纽值时，end 指针向前移动
    while (array[end] >= pivot && start < end) {
      end--;
    }

    // 将比枢纽值小的值交换到 start 位置
    array[start] = array[end];

    // 移动 start 值，当 start 指针指向的值小于枢纽值时，start 指针向后移动
    while (array[start] < pivot && start < end) {
      start++;
    }

    // 将比枢纽值大的值交换到 end 位置，进入下一次循环
    array[end] = array[start];
  }

  // 将枢纽值交换到中间点
  array[start] = pivot;

  // 返回中间索引值
  return start;
}

function heapSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  buildMaxHeap(array); // 将传入的数组建立为大顶堆

  // 每次循环，将最大的元素与末尾元素交换，然后剩下的元素重新构建为大顶堆
  for (let i = length - 1; i > 0; i--) {
    swap(array, 0, i);
    adjustMaxHeap(array, 0, i); // 将剩下的元素重新构建为大顶堆
  }

  return array;
}


function adjustMaxHeap(array, index, heapSize) {
  let iMax,
    iLeft,
    iRight;

  while (true) {
    iMax = index; // 保存最大值的索引
    iLeft = 2 * index + 1; // 获取左子元素的索引
    iRight = 2 * index + 2; // 获取右子元素的索引

    // 如果左子元素存在，且左子元素大于最大值，则更新最大值索引
    if (iLeft < heapSize && array[iMax] < array[iLeft]) {
      iMax = iLeft;
    }

    // 如果右子元素存在，且右子元素大于最大值，则更新最大值索引
    if (iRight < heapSize && array[iMax] < array[iRight]) {
      iMax = iRight;
    }

    // 如果最大元素被更新了，则交换位置，使父节点大于它的子节点，同时将索引值跟新为被替换的值，继续检查它的子树
    if (iMax !== index) {
      swap(array, index, iMax);
      index = iMax;
    } else {

      // 如果未被更新，说明该子树满足大顶堆的要求，退出循环
      break;
    }
  }
}

// 构建大顶堆
function buildMaxHeap(array) {
  let length = array.length,
    iParent = parseInt(length >> 1) - 1; // 获取最后一个非叶子点的元素

  for (let i = iParent; i >= 0; i--) {
    adjustMaxHeap(array, i, length); // 循环调整每一个子树，使其满足大顶堆的要求
  }
}

// 交换数组中两个元素的位置
function swap(array, i, j) {
  let temp = array[i];
  array[i] = array[j];
  array[j] = temp;
}

function radixSort(array) {

  let length = array.length;

  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  let bucket = [],
    max = array[0],
    loop;

  // 确定排序数组中的最大值
  for (let i = 1; i < length; i++) {
    if (array[i] > max) {
      max = array[i];
    }
  }

  // 确定最大值的位数
  loop = (max + '').length;


  // 初始化桶
  for (let i = 0; i < 10; i++) {
    bucket[i] = [];
  }

  for (let i = 0; i < loop; i++) {
    for (let j = 0; j < length; j++) {
      let str = array[j] + '';

      if (str.length >= i + 1) {
        let k = parseInt(str[str.length - 1 - i]); // 获取当前位的值，作为插入的索引
        bucket[k].push(array[j]);
      } else {
        // 处理位数不够的情况，高位默认为 0
        bucket[0].push(array[j]);
      }
    }

    array.splice(0, length); // 清空旧的数组

    // 使用桶重新初始化数组
    for (let i = 0; i < 10; i++) {
      let t = bucket[i].length;

      for (let j = 0; j < t; j++) {
        array.push(bucket[i][j]);
      }

      bucket[i] = [];
    }
  }

  return array;

}

// 节点类，树的节点
class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }

  show() {
    console.log(this.value);
  }
}

class BinarySearchTree {

  constructor() {
    this.root = null
  }

}

insert(value) {

  let newNode = new Node(value);

  // 判断根节点是否为空，如果不为空则递归插入到树中
  if (this.root === null) {
    this.root = newNode;
  } else {
    this.insertNode(this.root, newNode);
  }
}

insertNode(node, newNode) {

  // 将插入节点的值与当前节点的进行比较，如果比当前节点小，则递归判断左子树，如果比当前节点大，则递归判断右子树。
  if (newNode.value < node.value) {
    if (node.left === null) {
      node.left = newNode;
    } else {
      this.insertNode(node.left, newNode);
    }
  } else {
    if (node.right === null) {
      node.right = newNode;
    } else {
      this.insertNode(node.right, newNode);
    }
  }

}

// 先序遍历通过递归实现
// 先序遍历则先打印当前节点，再递归打印左子节点和右子节点。
 preOrderTraverse() {
   this.preOrderTraverseNode(this.root);
 }

 preOrderTraverseNode(node) {
   if (node !== null) {
     node.show();
     this.preOrderTraverseNode(node.left);
     this.preOrderTraverseNode(node.right);
   }
 }

 // 中序遍历通过递归实现
 // 中序遍历则先递归打印左子节点，再打印当前节点，最后再递归打印右子节点。
 inOrderTraverse() {
   this.inOrderTraverseNode(this.root);
 }

 inOrderTraverseNode(node) {
   if (node !== null) {
     this.inOrderTraverseNode(node.left);
     node.show();
     this.inOrderTraverseNode(node.right);
   }
 }

 // 后序遍历通过递归实现
 // 后序遍历则先递归打印左子节点和右子节点，最后再打印当前节点。
 postOrderTraverse() {
   this.postOrderTraverseNode(this.root);
 }

 postOrderTraverseNode(node) {
   if (node !== null) {
     this.postOrderTraverseNode(node.left);
     this.postOrderTraverseNode(node.right);
     node.show();
   }
 }

// 先序遍历通过循环实现
// 通过栈来实现循环先序遍历，首先将根节点入栈。然后进入循环，每次循环开始，当前节点出栈，打印当前节点，然后将
// 右子节点入栈，再将左子节点入栈，然后进入下一循环，直到栈为空结束循环。
preOrderTraverseByStack() {
  let stack = [];

  // 现将根节点入栈，开始遍历
  stack.push(this.root);

  while (stack.length > 0) {

    // 从栈中获取当前节点
    let node = stack.pop();

    // 执行节点操作
    node.show();

    // 判断节点是否还有左右子节点，如果存在则加入栈中，注意，由于中序遍历先序遍历是先访问根
    // 再访问左和右子节点，因此左右子节点的入栈顺序应该是反过来的
    if (node.right) {
      stack.push(node.right);
    }

    if (node.left) {
      stack.push(node.left);
    }
  }
}

// 中序遍历通过循环实现
// 中序遍历先将所有的左子节点入栈，如果左子节点为 null 时，打印栈顶元素，然后判断该元素是否有右子树，如果有
// 则将右子树作为起点重复上面的过程，一直循环直到栈为空并且节点为空时。
inOrderTraverseByStack() {
  let stack = [],
    node = this.root;

  // 中序遍历是先左再根最后右
  // 所以首先应该先把最左边节点遍历到底依次 push 进栈
  // 当左边没有节点时，就打印栈顶元素，然后寻找右节点
  while (stack.length > 0 || node) {
    if (node) {
      stack.push(node);
      node = node.left;
    } else {
      node = stack.pop();
      node.show();
      node = node.right;
    }
  }
}

// 后序遍历通过循环来实现
// 使用两个栈来是实现，先将根节点放入栈1中，然后进入循环，每次循环将栈顶元素加入栈2，再依次将左节点和右节点依次
// 加入栈1中，然后进入下一次循环，直到栈1的长度为0。最后再循环打印栈2的值。
postOrderTraverseByStack() {
  let stack1 = [],
    stack2 = [],
    node = null;

  // 后序遍历是先左再右最后根
  // 所以对于一个栈来说，应该先 push 根节点
  // 然后 push 右节点，最后 push 左节点

  stack1.push(this.root);

  while (stack1.length > 0) {
    node = stack1.pop();

    stack2.push(node);  
    
    if (node.left) {
      stack1.push(node.left);
    }
    
    if (node.right) {
      stack1.push(node.right);
    }

  }

  while (stack2.length > 0) {
    node = stack2.pop();
    node.show();
  }
}

// 寻找最小值，在最左边的叶子节点上
 findMinNode(root) {
   let node = root;

   while (node && node.left) {
     node = node.left;
   }

   return node;
 }

 // 寻找最大值，在最右边的叶子节点上

 findMaxNode(root) {
   let node = root;

   while (node && node.right) {
     node = node.right;
   }

   return node;
 }

// 寻找特定值
find(value) {
  return this.findNode(this.root, value);
}

findNode(node, value) {

  if (node === null) {
    return node;
  }
  if (value < node.value) {
    return this.findNode(node.left, value);
  } else if (value > node.value) {
    return this.findNode(node.right, value);
  } else {
    return node;
  }
}

// 移除指定值节点
remove(value) {
  this.removeNode(this.root, value);
}
removeNode(node, value) {

  if (node === null) {
    return node;
  }

  // 寻找指定节点
  if (value < node.value) {
    node.left = this.removeNode(node.left, value);
    return node;
  } else if (value > node.value) {
    node.right = this.removeNode(node.right, value);
    return node;
  } else { // 找到节点

    // 第一种情况——没有叶节点
    if (node.left === null && node.right === null) {
      node = null;
      return node;
    }

    // 第二种情况——一个只有一个子节点的节点，将节点替换为节点的子节点
    if (node.left === null) {
      node = node.right;
      return node;
    } else if (node.right === null) {
      node = node.left;
    }

    // 第三种情况——一个有两个子节点的节点，去右子树中找到最小的节点，用它的值来替换当前节点
    // 的值，保持树的特性，然后将替换的节点去掉
    let aux = this.findMinNode(node.right);
    node.value = aux.value;
    node.right = this.removeNode(node.right, aux);
    return node;
  }
}

var reverseList = function(head) {
    // 判断下变量边界问题
    if (!head || !head.next) return head;
    // 初始设置为空，因为第一个节点反转后就是尾部，尾部节点指向 null
    let pre = null;
    let current = head;
    let next;
    // 判断当前节点是否为空
    // 不为空就先获取当前节点的下一节点
    // 然后把当前节点的 next 设为上一个节点
    // 然后把 current 设为下一个节点，pre 设为当前节点
    while(current) {
        next = current.next;
        current.next = pre;
        pre = current;
        current = next;
    }
    return pre;
};

function getClimbingWays(n) {

  if (n < 1) {
    return 0;
  }

  if (n === 1) {
    return 1;
  }

  if (n === 2) {
    return 2;
  }

  return getClimbingWays(n - 1) + getClimbingWays(n - 2);
}

let map = new Map();

function getClimbingWays(n) {

  if (n < 1) {
    return 0;
  }

  if (n === 1) {
    return 1;
  }

  if (n === 2) {
    return 2;
  }

  if (map.has(n)) {
    return map.get(n);
  } else {
    let value = getClimbingWays(n - 1) + getClimbingWays(n - 2);
    map.set(n, value);
    return value;
  }
}

function getClimbingWays(n) {

  if (n < 1) {
    return 0;
  }

  if (n === 1) {
    return 1;
  }

  if (n === 2) {
    return 2;
  }

  let a = 1,
    b = 2,
    temp = 0;

  for (let i = 3; i <= n; i++) {
    temp = a + b;
    a = b;
    b = temp;
  }

  return temp;
}

主要思路是通过将数字转换为字符串，然后每个字符串在按位相加。

function bigNumberAdd(number1, number2) {

  let result = "", // 保存最后结果
    carry = false; // 保留进位结果

  // 将字符串转换为数组
  number1 = number1.split("");
  number2 = number2.split("");

  // 当数组的长度都变为0，并且最终不再进位时，结束循环
  while (number1.length || number2.length || carry) {

    // 每次将最后的数字进行相加，使用~~的好处是，即使返回值为 undefined 也能转换为 0
    carry += ~~number1.pop() + ~~number2.pop();

    // 取加法结果的个位加入最终结果
    result = carry % 10 + result;

    // 判断是否需要进位，true 和 false 的值在加法中会被转换为 1 和 0
    carry = carry > 9;
  }

  // 返回最终结果
  return result;
}

   // 这一种方法通过递归来实现，当元素为数组时递归调用，兼容性好
   function flattenArray(array) {

     if (!Array.isArray(array)) return;

     let result = [];

     result = array.reduce(function (pre, item) {
       // 判断元素是否为数组，如果为数组则递归调用，如果不是则加入结果数组中
       return pre.concat(Array.isArray(item) ? flattenArray(item) : item);
     }, []);

     return result;
   }

   //使用递归的形式进行数组打平
   function flatArray(arr){
    let result = [];
    function flat(arr){
        arr.forEach(element => {
            if(Array.isArray(element)){
                flat(element);
            }else{
                result.push(element);
            }
        });
    }

    flat(arr);
    return result;
}

   // 这一种方法是利用了 toString 方法，它的一个缺点是改变了元素的类型，只适合于数组中元素都是整数的情况
   function flattenArray(array) {
     return array.toString().split(",").map(function (item) {
       return JSON.parse(item);
     })
   }

function unique(array) {
  if (!Array.isArray(array) || array.length <= 1) return;

  var result = [];

  array.forEach(function (item) {
    if (result.indexOf(item) === -1) {
      result.push(item);
    }
  })

  return result;
}


function unique(array) {
  if (!Array.isArray(array) || array.length <= 1) return;

  return [...new Set(array)];
}

var arr = [6, 4, 1, 8, 2, 11, 23];
console.log(Math.max.apply(null, arr))

基本思想是采用辗转相除的方法，用大的数去除以小的那个数，然后再用小的数去除以的得到的余数，一直这样递归下去，
直到余数为0时，最后的被除数就是两个数的最大公约数。

function getMaxCommonDivisor(a, b) {
  if (b === 0) return a;

  return getMaxCommonDivisor(b, a % b);
}

基本思想是采用将两个数相乘，然后除以它们的最大公约数

function getMinCommonMultiple(a, b){
  return a * b / getMaxCommonDivisor(a, b);
}

function indexFun(array, val) {
  if (!Array.isArray(array)) return;

  let length = array.length;

  for (let i = 0; i < length; i++) {
    if (array[i] === val) {
      return i;
    }
  }

  return -1;
}   

function isPalindrome(str) {
  let reg = /[\W_]/g, // 匹配所有非单词的字符以及下划线
    newStr = str.replace(reg, "").toLowerCase(), // 替换为空字符并将大写字母转换为小写
    reverseStr = newStr.split("").reverse().join(""); // 将字符串反转

  return reverseStr === newStr;
}

function sum(...args) {

let result = 0;

result = args.reduce(function (pre, item) {
  return pre + item;
}, 0);

let add = function (...args) {

  result = args.reduce(function (pre, item) {
    return pre + item;
  }, result);

  return add;
};

add.valueOf = function () {
  console.log(result);
}

return add;
}

// forEach
function forEachUseReduce(array, handler) {
  array.reduce(function (pre, item, index) {
    handler(item, index);
  }, null);
}

// map
function mapUseReduce(array, handler) {
  let result = [];

  array.reduce(function (pre, item, index) {
    let mapItem = handler(item, index);
    result.push(mapItem);
  }, null);

  return result;
}

// filter
function filterUseReduce(array, handler) {
  let result = [];

  array.reduce(function (pre, item, index) {
    if (handler(item, index)) {
      result.push(item);
    }
  }, null);

  return result;
}

class Queue {

  constructor() {
    this.queue = [];
    this.time = 0;
  }

  addTask(task, t) {
    this.time += t;
    this.queue.push([task, this.time]);
    return this;
  }

  start() {
    this.queue.forEach(item => {
      setTimeout(() => {
        item[0]();
      }, item[1]);
    })
  }
}

function findMostWord(article) {

// 合法性判断
if (!article) return;

// 参数处理
article = article.trim().toLowerCase();

let wordList = article.match(/[a-z]+/g),
 visited = [],
 maxNum = 0,
 maxWord = "";

article = " " + wordList.join("  ") + " ";

// 遍历判断单词出现次数
wordList.forEach(function (item) {
 if (visited.indexOf(item) < 0) {
   let word = new RegExp(" " + item + " ", "g"),
     num = article.match(word).length;

   if (num > maxNum) {
     maxNum = num;
     maxWord = item;
   }
 }
});

return maxWord + "  " + maxNum;

}