做题

排序

1.在一个数组中，如果一个数是要被排序的（假如递增），那么它的左边一定有一个数比它大，或者右边有一个数比它小；题目：正反(max,min)两次遍历找到待排序区间

2.sort函数

　　只对字母进行排序，只需要使用sort()；数字才需要排序函数

// 排序需要提供比较函数，该函数比较两个值的大小，然后返回一个用于说明这两个值的相对顺序的数字
            // 两个参数a和b
            // 若a小于b，即a-b小于0，则返回一个小于0的值，数组升序
            // 若a大于b.数组降序
            var arr = ['12', '323', '1000', '50']
            // 升序
            function sortNum1(a, b) {
                  // 默认a-b小于0，即升序；降序可用b-a
                  return a-b
            }
            // 降序
            function sortNum2(a, b) {
                  return b-a
            }
            console.log(arr);
            console.log(arr.sort(sortNum1));
            console.log(arr.sort(sortNum2));

            // 按照数组对象中某个属性值进行排序
            var arr1 = [
                  {name:'zhangsan', age:34},
                  {name:'lisi', age:30},
                  {name:'wangwu', age:60},
            ]
            function compare(prop) {
                  return function(a, b) {
                        var value1 = a[prop]
                        var value2 = b[prop]
                        // 默认value1-value2升序
                        return value2-value1
                  }
            }
            console.log(arr1.sort(compare('age')));

 　　比较多元数组：

var arr = [[1,3,564],[15,2,154],[8,10,54],[2,6,879]]
            arr.sort(function(a, b) {
                  // 其中是待比较的数的索引
                  return a[2]-b[2]
            })
            console.log(arr)

 3.字符串转数组，最快

let str = "fsiuiuaiusahbusa"
console.log([...str]);

　　浅拷贝：对于基础数据类型，拷贝的时候会完整地复制一份；对于引用数据类型，拷贝的是对象的引用，当原对象发生变化的时候，拷贝对象也会发生变化

　　扩展运算符：用于取出参数对象中的所有可遍历属性，拷贝（浅拷贝）到当前对象中

let obj1 = { a: 1, b: 2};
let obj2 = { ...obj1, b: '2-edited'};
console.log(obj1); // {a: 1, b: 2}
console.log(obj2); //  {a: 1, b: "2-edited"}

　　扩展运算符可以和解构赋值结合起来，用于生成数组（但是在这种用法下，扩展运算符只能放在参数的最后一位）

const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest  // [2, 3, 4, 5]

4.数组转字符串

　　join()：用数组的元素组成字符串，默认输出的字符串是每个数组元素用逗号分隔的形式，可以使用join('-')来使用-分隔输出元素

[...s].sort().join('')

 5.数组去重

　　用set：

let nums = [5,5,1,1,54,]
const set = new Set();
for (let i = 0; i <= len; i++) {
　　// set.has(num)判断该值是否在set中已存在，返回布尔值
    if (!set.has(nums[i])) {
      set.add(nums[i]);
    }
}
// 将类数组对象或可便利对象转换为一个真正的数组
let arr = Array.from(set)

 6.二分查找

// 简单的二分查找
    var binarySearch = function (nums, target) {
        let left = 0
        let right = nums.length - 1

        while (left <= right) {
            // 取中间节点
            let mid = (right + left) / 2
            if (nums[mid] == target) {
                return mid
            } else if (nums[mid] < target) {
                // 更换左边界
                left = mid + 1
            } else if (nums[mid] > target) {
                // 更换右边界
                right = mid - 1
            }
        }
        return -1
    }

// 寻找右侧边界
    let binarySearchRight = function (nums, target) {
        if (nums.length == 0) return -1
        // 因为初始化是right = num.length，所以决定了left=mid+1和right=mid（mid给right相当于right=num.length，即右边界都取不到）
        let left = 0, right = num.length

        while (left < right) {
            let mid = (left + right) / 2
            if (nums[mid] == target) {
                // 有差别，收紧左侧边界
                left = mid + 1
                // 如果target大于mid值，那么增大left，使区间不断向右收缩，即寻找右侧端点
            } else if (nums[mid] < target) {
                left = mid + 1
                // 如果target小于mid值，那么更换右端点
            } else if (nums[mid] > target) {
                right = mid
            }
        }
        // 有差别
        return left - 1
    }

    // 寻找左侧边界
    let binarySearchRight = function (nums, target) {
        if (nums.length == 0) return -1
        let left = 0, right = num.length

        while (left < right) {
            let mid = (left + right) / 2
            if (nums[mid] == target) {
                // 有差别，收紧右侧边界以锁定左侧边界
                right = mid
            } else if (nums[mid] < target) {
                left = mid + 1
            } else if (nums[mid] > target) {
                right = mid
            }
        }
        // 有差别
        return left
    }