leetcode Day53 剑指专项75-79

873. 最长的斐波那契子序列的长度

var lenLongestFibSubseq = function(arr) {
    let map=new Map()
    for(let i=0;i<arr.length;i++){
        map.set(arr[i],i)
    }
    const dp=new Array(arr.length).fill(0).map(()=>new Array(arr.length).fill(0))
    let res=0
    for(let i=0;i<arr.length;i++){
        for(let j=arr.length-1;j>=0;j--){
            if(arr[j]*2<=arr[i]){
                break
            }
            if(map.has(arr[i]-arr[j])){
                let k=map.get(arr[i]-arr[j])
                dp[j][i]=Math.max(dp[k][j]+1,3)
                res=Math.max(res,dp[j][i])
            }
        }
    }
    return res
};

剑指 Offer II 075. 数组相对排序

var relativeSortArray = function(arr1, arr2) {
    //map存贮idx
    let map=new Map()
    for(let i=0;i<arr2.length;i++){
        map.set(arr2[i],i+1)
    }
    arr1.sort((a,b)=>{
        if(map.has(a)&&map.has(b)){
            return map.get(a)-map.get(b)
        }
        else if(map.has(a))return -1
        else if(map.has(b))return 1
        else{return a-b}
    })
    return arr1
};

剑指 Offer II 076. 数组中的第 k 大的数字

var findKthLargest = function(nums, k) {
    nums.sort((a,b)=>a-b)
    return nums[nums.length-k]
};

剑指 Offer II 077. 链表排序

var sortList = function(head) {
    //数组值排序再生成链表
    let node=head
    let res=[]
    while(node){
        res.push(node.val)
        node=node.next
    }
    res.sort((a,b)=>a-b)
    let dummyHead=new ListNode(0)
    let vnode=dummyHead
    for(let i of res){
        vnode.next=new ListNode(i)
        vnode=vnode.next
    }
    return dummyHead.next
};

var sortList = function(head) {
    //归并排序
    return toSortList(head,null)
};
const toSortList=(head,tail)=>{
    //切分为最小单元0个或1个
    if(!head){
        return head
    }
    if(head.next===tail){
        head.next=null
        return  head
    }
    let slow=head,fast=head
    while(fast!==tail){
        slow=slow.next
        fast=fast.next
        if(fast!==tail){
            fast=fast.next
        }
    }
    let mid=slow
    return merge(toSortList(head,mid),toSortList(mid,tail))
}
const merge=(head1,head2)=>{
    //排序合并
    const dummyNode=new ListNode(0)
    let node=dummyNode,node1=head1,node2=head2
    while(node1 &&node2){
        if(node1.val<node2.val){
            node.next=node1
            node1=node1.next
        }else{
            node.next=node2
            node2=node2.next
        }
        node=node.next
    }
    if(node1){
        node.next=node1
    }else if(node2){
        node.next=node2
    }
    return dummyNode.next
}

剑指 Offer II 078. 合并排序链表

var mergeKLists = function (lists) {
  var len = lists.length
  if (len < 2) {
    return lists[0] || null
  }
  const mid = Math.floor(len / 2)
  return merge(mergeKLists(lists.slice(0, mid)), mergeKLists(lists.slice(mid)))
};

var merge = function (l1, l2) {
  if (!l1) {
    return l2
  }
  if (!l2) {
    return l1
  }
  var head
  if (l1.val > l2.val) {
    head = l2
    head.next = merge(l1, l2.next)
  } else {
    head = l1
    head.next = merge(l1.next, l2)
  }
  return head
}

剑指 Offer II 079. 所有子集

var subsets = function(nums) {
    let res=[[]]
    for(let num of nums){
        let add=[]
        for(let i of res){
            add.push([...i,num])
        }
        res=[...res,...add]
    }
    return res
};