单链表--oj题

Posted 2021-05-24 水澹澹兮生烟.

在刷算法题经常遇到的关于单链表的题。

1.给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
在这道题中，我们要对其不同情况而进行不同的处理，这里我们需要关心头结点是否要进行删除。

struct ListNode* removeElements(struct ListNode* head, int val){
   struct ListNode* cur=head;
   if(!head) return head;
   while(head&&head->val==val){//进行头删
    head=cur->next;
    cur=head;
   }
   while(head){
       if (head->next && head->next->val == val)
        {
            head->next = head->next->next;
        }
        head = head->next;
   }
   return cur;
}

2.给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
对链表进行翻转 1->2->3->4->NULL，翻转成 NULL<-1<-2<-3<-4,此时，我们课已使用三指针的方法，进行逆置。

1.迭代法

struct ListNode* reverseList(struct ListNode* head){
     struct ListNode* prve=NULL;
     struct ListNode* curr=NULL;
    if(head==NULL||head->next==NULL) return head;
    while(head!=NULL){
        curr=head->next;//保存当前结点的下一个结点
        head->next=prve;//当前的结点指向上一个结点
        prve=head;//前指针后移
        head=curr;//当前结点指针后移
    }
    return prve;
}

2.递归

struct ListNode* reverse(struct ListNode*prve,struct ListNode* curr){
    if(curr==NULL) return prve;
    else{
        struct ListNode* knownode=curr->next;
        curr->next=prve;
        prve=curr;
        curr=knownode;
        return reverse(prve,curr);
    }
}
struct ListNode* reverseList(struct ListNode* head){
    return reverse(NULL,head);
}

3.给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
我们进行分析可知，要返回链表的中间结点，可以采用快慢指针的方式，从开始进行遍历，当快指针移动两个结点时，慢指针移动一个结点，因此，当快指针到达链表末尾时，慢指针刚好到达链表的中间结点。

struct ListNode* middleNode(struct ListNode* head){
    //双指针遍历
    struct ListNode* p1=NULL;
    struct ListNode* p2=NULL;
    int count=0;
    if(!head||!head->next) return head;
    p1=head;
    p2=head->next;
    while(p2!=NULL){
        count++;
        p1=(count%2==0)?p1:p1->next;
        p2=p2->next;
    }
    return p1;
}

4.将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
在进行两个有序链表合并时，我们必须注意最重要的一步是首先给新链表虚拟一个头结点，并且固定好头结点，然后在比较两个链表每个结点的值，往新链表里面插入。

下面进行插入头结点：

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    struct ListNode* head=NULL;//虚拟头节点
    struct ListNode* tail=NULL;//新链表中的最后一个结点
    if(l1==NULL) return l2;
    if(l2==NULL) return l1;
    if(l1!=NULL&&l2!=NULL){
        if(l1->val<l2->val){//首先固定好头结点
             head=l1;
             l1=l1->next;
             tail=head;
         }else{
             head=l2;
             l2=l2->next;
             tail=head;
         }
    }
    while(l1!=NULL&&l2!=NULL){
        if(l1->val<l2->val){
            tail->next=l1;
            l1=l1->next;
            tail=tail->next;//结束后，将尾结点后移
        }else{
            tail->next=l2;
            l2=l2->next;
            tail=tail->next;
        }
    }
    //如果此时循环结束，但是还有链表的结点没有插入结束
    if(l1!=NULL){
        tail->next=l1;
    }
    if(l2!=NULL){
        tail->next=l2;
    }
    return head;
}