数组有关算法

剑指 Offer II 074. 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/SsGoHC

var merge = function(intervals) {
    let result = [];
    // 排序
    intervals.sort((a,b) => {
        return a[0] - b[0];
    });
    for(let i = 0; i < intervals.length; i++) {
        let noMerge = 1;
        if(result.length && (intervals[i][0] <= result[result.length-1][1])
            && (result[result.length-1][0] <= intervals[i][0])) {
            noMerge = 0;
            if (result[result.length-1][1] < intervals[i][1]) result[result.length-1][1] = intervals[i][1];
        } 
        if (noMerge) result.push(intervals[i]);
    }
    return result;
};
merge( [[1,4],[4,5]]);

剑指 Offer II 073. 狒狒吃香蕉

狒狒喜欢吃香蕉。这里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。
狒狒可以决定她吃香蕉的速度 K （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 K 根。如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉，下一个小时才会开始吃另一堆的香蕉。
狒狒喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。
返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。

以速度作为二分法查找的序列，速度范围【1， max】，去计算对应二分速度对应的时间和指定时间的大小，缩小范围，直至范围无效。

var minEatingSpeed = function(piles, h) {
   let max = 0;
   for(let i of piles) {
       i > max ? max = i : null;
   }
   let rage = [1,max];
   let t, k ,v;
  while(rage[0] <= rage[1]) {
       v = Math.ceil((rage[0]+rage[1])/2);
       t = getHour(v);
       t > h ? (rage[0] = v+1) : (k = v, rage[1] = v-1);
   }
   return k;
   function getHour(k) {
       let t = 0;
       for(let i of piles) {
           t += Math.ceil(i/k);
       }
       // console.log(t);
       return t;
   }
};

两个子序列有序的查找

数组为两个有序的子序列，时间复杂度nlogn

function find(a, x) {
  let left = 0,
    right = a.length - 1;
  while (left + 1 < right) {
    let index = Math.floor((left + right) / 2);
    let mid = a[index];
    mid < a[right]
      ? x > a[right] || x < mid
        ? (right = index)
        : (left = index)
      : x > a[right] && x < mid ? right = index : left = index;
  }
  return x == a[left] ? left : -1;
}
// 最中间的数小于最右边的数则证明右侧有序
    // if (mid < a[right]) {
    //     if (x > a[right] || x < mid) {
    //         right = index;
    //     } else {
    //         left = index;
    //     }
    // } else {
    // 左边有序，判断最左边的数据和x的大小
    //     if (x < a[left] || x > mid) {
    //         left = index;
    //     } else {
    //         right = index;
    //     }
    // }
console.log(find([7, 8, 9, 1, 2, 3, 4, 5, 6], 1));

136. 只出现一次的数字（简单）

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

这道题本身不复杂，主要想记录一下它有哪些解决思路，以及最优解法

方法1： 用额外hash存遍历一遍元素，若元素重复出现就在hash中删除该元素,最后的元素就是所求结果。O（n）空间， O（n）时间
方法2： 用额外hash存遍历一遍元素，并求和，hash元素求和的2倍-数组求和 的结果就是所求元素。O（n）空间， O（n）时间
方法3：暴力解法，两层循环寻找是否有重复元素，未重复就return当前外层元素。O（1）空间， O（n^2）时间
方法四： 异或，由于元素出现的规律，相同元素异或为0，所以全部异或的结果就是该元素。

var singleNumber = function(nums) {
    // 数组中的全部元素的异或运算结果即为数组中只出现一次的数字
    let result = 0;
    for(let i = 0; i < nums.length; i++) {
        result ^= nums[i];
    }
    return result;
};

持续更新中。。。。