链表基础操作

链表定义

    function listNode(val,next){
        this.val = (val===undefined?0:val)
        this.next = (next===undefined?null:next)
    }

建立链表

head->A->B->C->D->E

function buildList(){
    var A=new listNode()
    var B=new listNode()
    var c=new listNode()
    var D=new listNode()
    var E=new listNode()
    D.next=E
    C.next=D
    B.next=C
    A.next=B
    let head=A
    return head
}

添加元素

head->A->B->C->D->E 添加M到B和C之间

    var M=new listNode()
    M.next=c
    B.next=M

删除元素

head->A->B->C->D->E 删除B

    A.next=B.next

反转链表

定义一个函数输入链表的头节点，反转该链表并输出反转后的链表头节点

输入: 1->2->3->4->5->NULL

输出: 5->4->3->2->1->NULL

    function reverseList(head){
        var pre = null
        var cur = head
        while(cur){
            let next = cur.next
            cur.next = pre
            pre = cur
            cur = next
            
        }
        return pre
    }

删除链表的节点

       function deleteNode(head,val){
           //判断是否头节点
           if(head.val==val){
               head=head.next
               return head
           }
           //如果不是头节点就开始遍历
           let pre=head
           let cur=head.next
           while(cur){
               if(cur.val==val){
                   pre.next=cur.next
                   break
               }
               pre = cur
               cur = cur.next
           }
           return head
       }

两个链表的第一个公共节点

两个如何才能相遇喃。。。。走的路程一样就会相遇了。。。如何走的路程一样，循环走，我走完我的再走你的，你走完你的再走我的。。。。在刷leecode的时候遇到了这个题目，看到了一句话

你变成我，走过我走过的路。我变成你，走过你走过的路。然后我们便相遇了 程序员也有浪漫的时候，这也是这题的思路，由于两个链表相遇之前的路程不一定一样长，所以第一个链表遍历之后开始遍历第二个，第二个链表遍历完了之后开始遍历第一个，相遇的时候就是他们相遇的节点

    function getIntersectionNode(headA,headB){
        //定义两个节点，像两个人一样
        let node1 = headA
        let node2 = headB
        while(node1!=node2){
            if(node1==null&&node2==null){break}
            node1=node1?node1.next:headB
            node2=node2?node2.next:headA
        }
        return node1
    }

数据结构-链表-相关题目