20180528-20180601 前端知识填坑

看到这周的题目想必各位都知道了...

本周主要是填坑很难受我哪来这么多坑!! 永远填不完!!

下面开始可能会很乱将就一下..

快速排序(阮一峰版本)

这个版本前段时间还是挺火的有人说这个版本很浪费资源现在看来确实是的不过很多人确实看着阮一峰老师的快排入了门

无所谓对错的挺阮一峰老师一下

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2);

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

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

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);

　　　　} else {

　　　　　　right.push(arr[i]);

　　　　}

　　}

　　return quickSort(left).concat([pivot], quickSort(right));

};

整个思想其实很简单,在无序的数组里选择一个数,比这个数小的放在左边,比这个数大的放在右边

再进行排序大概就是这么个思想

但是,为什么前段时间阮一峰的快排被吐槽了呢

1.每次定义了两个临时数组

2.splice增加了复杂度

解决办法原地交换, 直接用下标取中间值

(有点着急下周一整理一下下面代码的格式)

         function swap(array, a, b) {
    [array[a], array[b]] = [array[b], array[a]];
  }
 function quick(array, left, right) {
    let index;
    if (array.length > 1) {
      index = partition(array, left, right);
      if (left < index - 1) {
        quick(array, left, index - 1);
      }
      if (index < right) {
        quick(array, index, right);
      }
    }
    return array;
  }
   // 划分操作函数
  function partition(array, left, right) {
    // 用index取中间值而非splice
    const pivot = array[Math.floor((right + left) / 2)];
    let i = left;
    let j = right;

    while (i <= j) {
      while (compare(array[i], pivot) === -1) {
        i++;
      }
      while (compare(array[j], pivot) === 1) {
        j--;
      }
      if (i <= j) {
        swap(array, i, j);
        i++;
        j--;
      }
    }
    return i;
  }
  
  // 比较函数
  function compare(a, b) {
    if (a === b) {
      return 0;
    }
    return a < b ? -1 : 1;
  }

function quickSort(array) {
    return quick(array, 0, array.length - 1);
};
console.log(quickSort([1,8,9,2,4,7]))

————————————————————————————————————————————————————

Math.floor()对一个数进行向下取整

parseInt取一个小数点前面的整数

Math.floor(-1.5) //-2
parseInt(-1.5) //-1

注意！！！ parseInt还有很多意想不到的用法（下周一更新）

比如：

parseInt(false,16) //250

结果是250 嘿嘿嘿嘿嘿想不到吧

————————————————————————————————————————————————————

0x是16进制开头 0是八进制开头

js中用0作除数会出现Infinity 使用字符串相关计算会出现NaN 另外NaN不等于NaN使用isNaN()进行判断

————————————————————————————————————————————————————

二分查找法

// 二分查找，前提是数组为有序数组
function binarySearch(target, arr) {
  let start = 0;
  let end = arr.length - 1;

  while (start <= end) {
    let mid = parseInt(start + (end - start) / 2);
    if (target == arr[mid]) {
      return mid;
    } else if (target > arr[mid]) {
      start = mid + 1;
    } else {
      end = mid - 1;
    }
  }
  return -1;
}

冒泡排序（强烈不建议使用）属于O（n²）复杂度的算法

function bubbleSort(arr) {
  let len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        // 相邻元素两两对比
        let temp = arr[j + 1]; // 元素交换
        arr[j + 1] = arr[j];
        arr[j] = temp;
      }
    }
  }
  return arr;
}

————————————————————————————————————————————————

call和apply

下面是一个很好记忆的方法，

——————————————————————————————————————

深克隆和浅克隆

　　function extendCopy(p) {

　　　　var c = {};

　　　　for (var i in p) { 
　　　　　　c[i] = p[i];
　　　　}

　　　　c.uber = p;

　　　　return c;
　　}
//浅克隆

　　function deepCopy(p, c) {

　　　　var c = c || {};

　　　　for (var i in p) {

　　　　　　if (typeof p[i] === 'object') {

　　　　　　　　c[i] = (p[i].constructor === Array) ? [] : {};

　　　　　　　　deepCopy(p[i], c[i]);

　　　　　　} else {

　　　　　　　　　c[i] = p[i];

　　　　　　}
　　　　}

　　　　return c;
　　}
//深克隆

区别在于浅克隆在复制时，对于对象及数组并没有复制层级

意思就是在值为对象（数组）时，克隆只带了地址所以在浅克隆里如果修改一处，那么另一处也会被修改

20180528-20180601 前端知识填坑

猜你喜欢