1、冒泡排序

依次比较两个相邻的元素，如果顺序错误就把他们交换过来。

  2. const arr = [911,520,888,666,555,2323]
  4. function bubbleSort(arr){
  5.     let temp;
  6.     for (let i = 0; i < arr.length-1; i++) {
  7.         for (let j = 0; j < arr.length-1-i; j++) {
  8.             if (arr[j]>arr[j+1]) {
  9.                 temp = arr[j];
  10.                 arr[j]= arr[j+1];
  11.                 arr[j+1] = temp;
  12.             }
  13.         }
  14.     }
  15.     return arr;
  16. }
  18. console.log(bubbleSort(arr));

2、递归（深拷贝）

  1. function deepClone(obj){
  2.   if (typeof obj !== 'object' || obj == null) {
  3.     return obj;
  4.   }
  6.   var result = obj instanceof Array?[]:{};
  8.   for (const k in obj) {
  9.     if (obj.hasOwnProperty(k)) {
  10.       result[k] = deepClone(obj[k]);
  11.     }
  12.   }
  14.   return result;
  16. }
  17. const obj = {
  18.   name:"cq",
  19.   age:18,
  20.   still:{
  21.     web:'vue',
  22.     others:'react'
  23.   }
  24. }
  25. const newObj = deepClone(obj)
  26. newObj.still.web = 'angular'
  27. console.log(newObj);
  28. console.log(obj);

3、数组去重

  1. function unique1(arr){
  2.   for (let i = 0; i < arr.length; i++) {
  3.     for (let j = i+1; j < arr.length; j++) {
  4.       if(arr[i] === arr[j]){
  5.         arr.splice(j,1);
  6.         j--;
  7.       }
  8.     }
  9.   }
  10.   return arr;
  11. }
  13. function unique2(arr){
  14.   var result = [];
  15.   for(let i=0;i<arr.length;i++){
  16.     if(result.indexOf(arr[i]) === -1){
  17.       result.push(arr[i])
  18.     }
  19.   }
  20.   return result;
  21. }
  23. function unique3(arr){
  24.   return Array.from(new Set(arr))
  25. }
  27. const arr = [1,2,3,1,1,2,4]
  28. console.log(unique1(arr));
  29. console.log(unique2(arr));
  30. console.log(unique3(arr));

4、快速排序

（1）在数据集之中，选择一个元素作为”基准”（pivot）。
（2）所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。
（3）对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

  1. const arr = [911,520,888,666,555,2323]
  2. //阮一峰版
  3. function quickSort(arr){
  4.   if (arr.length<=1) return arr;
  5.   var pivotIndex = 0;
  6.   var pivot = arr.splice(pivotIndex,1)[0];
  7.   var left = [];
  8.   var right = [];
  9.   for (let i = 0; i < arr.length; i++) {
  10.     if(arr[i]<pivot){
  11.       left.push(arr[i])
  12.     }else{
  13.       right.push(arr[i])
  14.     }
  15.   }
  16.   return quickSort(left).concat([pivot],quickSort(right))
  17. }
  19. //新版
  20. function quickSort(arr) {
  21.   function swap(arr, i, k) {        
  22.     let temp = arr[i];
  23.     arr[i] = arr[k];
  24.     arr[k] = temp;
  25.   }
  26.   // 数组分区，左小右大
  27.   function partition(arr, left, right) {        
  28.     let storeIndex = left;        
  29.     let pivot = arr[right]; // 直接选最右边的元素为基准元素
  30.     for(let i = left; i < right; i++) {            
  31.       if(arr[i] < pivot) {
  32.         swap(arr, storeIndex, i);
  33.         storeIndex++; // 交换位置后，storeIndex 自增 1，代表下一个可能要交换的位置
  34.       } 
  35.     }
  36.     swap(arr, storeIndex, right); // 将基准元素放置到最后的正确位置上
  37.     return storeIndex;
  38.   }
  39.   function sort(arr, left, right) {        
  40.     if(left > right) {            
  41.       return;
  42.     }        
  43.     let storeIndex = partition(arr, left, right);
  44.     sort(arr, left, storeIndex - 1);
  45.     sort(arr, storeIndex + 1, right);
  46.   }
  47.   sort(arr, 0, arr.length - 1);    
  48.   return arr;
  49. }
  51. console.log(quickSort(arr));

5、翻转字符串

  1. function reverseString(str) {
  2.   str=str.split('').reverse().join('');
  3.   return str;
  4. }
  5. reverseString("hello");

6、翻转二叉树

这是一道很经典的二叉树问题。显然，我们从根节点开始，递归地对树进行遍历，并从叶子节点先开始翻转。如果当前遍历到的节点 root 的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以root 为根节点的整棵子树的翻转。

  1. var invertTree = function(root) {
  2.     if (root === null) {
  3.         return null;
  4.     }
  5.     const left = invertTree(root.left);
  6.     const right = invertTree(root.right);
  7.     root.left = right;
  8.     root.right = left;
  9.     return root;
  10. };
  12. //测试
  13. var obj={
  14.   'id':'4',        
  15.   'left':{
  16.     'id':'2',
  17.     'left':{
  18.       'id':'1',
  19.       'left':null,
  20.       'right':null
  21.     },
  22.     'right':{
  23.       'id':'3',
  24.       'left':null,
  25.       'right':null
  26.     }
  27.   },
  28.   'right':{
  29.     'id':'7',
  30.     'left':{
  31.       'id':'6',
  32.       'left':null,
  33.       'right':null
  34.     },
  35.     'right':{
  36.       'id':'9',
  37.       'left':null,
  38.       'right':null
  39.     }
  40.   }
  41. }
  43. invertTree(obj);
  44. console.log(obj);

leetcode链接：https://leetcode-cn.com/problems/invert-binary-tree/

7、防抖节流

防抖：事件触发后，在n秒内，如果再次触发事件，则会重新计时

  1. debunce(fn,delay){
  2.     let timer = null;
  3.     return function(){
  4.         if(timer){
  5.             clearTimeout(timer)
  6.         }
  7.         timer = setTimeout(() =>{
  8.             fn()
  9.         },delay)
  10.     }
  11. }

节流：事件触发后，在n秒内，再次触发事件，都会无效，只会触发一次

  1. throttle(fn,delay){
  2.     let lock = true
  3.     return function () {
  4.         if(!lock){
  5.             return
  6.         }
  7.         lock = false
  8.         setTimeout(() => {
  9.             fn()
  10.             lock = true
  11.         },delay)
  12.     }
  13. },

8、打印 out5 in0 in1 in2 in3 in4

  1. for (var i = 0; i < 5; i++) {
  2.   (function(i){
  3.     setTimeout(async function() {
  4.       console.log('in', i);
  5.     }, 1000);
  6.   })(i)
  7. }
  8. console.log('out', i);

9、判断一个{}为空

  1. var a = {}
  2. console.log(JSON.stringify(a) === '{}');