数据结构--链表基础练习题

1、反转链表

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

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    var cur=head;
    var temp;//临时变量
    var prev=null;//最终结果
    while(cur){
        temp=cur.next;//把后面的值赋给temp
        cur.next=prev;//反转链表
        prev=cur;//反转后的结果存起来。
        cur=temp;//把后续值给cur，继续循环
    }
    return prev;
};

 2、删除链表的某个节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var deleteNode = function(head, val) {
    var res=new ListNode();
    res.next=head;//防止删除的是头节点
    let now=res;
    while(now.next)//防止删除的是尾节点
    {
        if(now.next.val==val){
            now.next=now.next.next;
        }
        else{
            now=now.next;
        }
    }
    return res.next;//此时不能返回now，此时now指向链表最后一个元素。
};

3、合并排序后的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    var dum=new ListNode();
    var res = dum;
    while(l1&&l2){
        if(l1.val<l2.val){//谁小，指向谁
            res.next=l1;
            l1=l1.next;
        }
        else{
            res.next=l2;
            l2=l2.next;
        }
        res=res.next;//res往后移
    }
    res.next=l1==null?l2:l1;//最后res指向不为空的链表
    return dum.next;//不能返回res
};

4、链表中倒数第k个数。

给定一个链表: 1->2->3->4->5, 和 k = 2.返回链表 4->5.

/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var getKthFromEnd = function(head, k) {
    var fast=head;//快慢指针
    var slow=head;
    while(fast){
        if(k>0){
            k--;
            fast=fast.next;//快指针先走k步
        }
        else{
            fast=fast.next;
            slow=slow.next;
        }
    }
    return slow;//slow既为返回结果
};

5、环形链表

给定一个链表，判断链表中是否有环。

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    var fast = head;//快慢指针
    var slow = head;
    while(fast&&fast.next){
        fast = fast.next.next;//快指针每次走两步，慢指针每次走一步
        slow = slow.next;
        if(fast == slow){//如果是环形链表，则必定会相遇
            return true;
        }
    }
    return false;
};

6、链表数组【中等】

给定链表头结点 head，该链表上的每个结点都有一个唯一的整型值 。同时给定列表 G，该列表是上述链表中整型值的一个子集。返回列表 G 中组件的个数，这里对组件的定义为：链表中一段最长连续结点的值（该值必须在列表 G 中）构成的集合。

输入: 
head: 0->1->2->3->4
G = [1,3,4]
输出: 2.    
共有两个连续数组。1是一个连续数组，3、4是一个连续数组。

/**
 * @param {ListNode} head
 * @param {number[]} G
 * @return {number}
 */
var numComponents = function(head, G) {
    var num=0;
    var isconnect=false;//是否连续
    while(head){
        if(G.indexOf(head.val)>-1){//如果值在链表中存在
            if(!isconnect){//不连续，则num++
                num++;
            }
            isconnect=true;
        }
        else{
            isconnect=false;
        }
        head=head.next;
    }
    return num;
};