leetcode Day14 链表

883. 三维形体投影面积

var projectionArea = function(grid) {
    const n=grid.length
    let xy=0,yz=0,zx=0
    for(let i=0;i<n;i++){
        let yzh=0,zxh=0
        for(let j=0;j<n;j++){
            xy+=grid[i][j]>0?1:0
            yzh=Math.max(yzh,grid[j][i])
            zxh=Math.max(zxh,grid[i][j])
        }
        yz+=yzh
        zx+=zxh
    }
    return xy+yz+zx
};

面试题 17.12. BiNode

var convertBiNode = function(root) {
    //中序遍历得到的结果就是有序的
    let vhead=new TreeNode(-1)
    let pre=vhead
    const dfs=function(node){
        if(!node)return
        dfs(node.left)
        pre.right=node
        node.left=null
        pre=pre.right
        dfs(node.right)
    }
    dfs(root)
    return vhead.right
};

剑指 Offer II 021. 删除链表的倒数第 n 个结点

var removeNthFromEnd = function(head, n) {
    //先算出链表长度，得到要删除的正数结点
    const dummyNode = new ListNode(0)
    dummyNode.next = head
    let l=0
    let node=dummyNode
    while(node){
        node=node.next
        l++
    }
    node=dummyNode
    for(let i=1;i<l-n;i++){
        node=node.next
    }
    node.next=node.next.next
    return dummyNode.next
};

var removeNthFromEnd = function(head, n) {
    //快慢指针，当快指针走到链表尾时，慢指针指向要删除结点的前一个结点
    let dummyNode=new ListNode(0)
    dummyNode.next=head
    let f=dummyNode,s=dummyNode
    for(let i=0;i<n;i++){
        f=f.next
    }
    while(f.next){
        s=s.next
        f=f.next
    }
    s.next=s.next.next
    return dummyNode.next
};

剑指 Offer II 025. 链表中的两数相加

var addTwoNumbers = function(l1, l2) {
    //反转后再相加
    l1=reverseList(l1)
    l2=reverseList(l2)
    let res=new ListNode(0)
    let pre=res
    let carry=0
    while(l1 || l2 || carry){
        let v1=l1===null?0:l1.val
        let v2=l2===null?0:l2.val
        let sum=v1+v2+carry
        pre.next=new ListNode(sum%10)
        pre=pre.next
        carry=Math.floor(sum/10)
        l1=l1===null?null:l1.next
        l2=l2===null?null:l2.next
    }
    return reverseList(res.next)
};
const reverseList=(l)=>{
    let node=l
    let pre=null,cur=null
    while(node){
        cur=node.next
        node.next=pre
        pre=node
        node=cur
    }
    return pre
}