代码随想录day03

203.移除链表元素

     题目链接

        题目：删除链表中等于给定值 val 的所有节点。

        示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

        示例 2： 输入：head = [], val = 1 输出：[]

        示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

        该题为简单题，唯一需要注意的是要添加一个虚拟头结点，使整个来拿表的删除操作进行统一起来。

struct ListNode* removeElements(struct ListNode* head, int val) {
    if(head==NULL) return NULL;
    struct ListNode *dum=malloc(sizeof(struct ListNode));
    dum->next=head;
    struct ListNode *p=dum,*temp=p->next;
    while(p->next!=NULL){
        if(p->next->val==val){//删除
           struct ListNode *temp=p->next;
           p->next=temp->next;
           free(temp);
        }else{
           p=p->next;
        }
    }
    return dum->next;
}

 707.设计链表

        此题回顾了链表各种操作。主要是查找、插入、删除等。在删除时要注意，要找的是删除元素前一个节点pre，而且进行判断时要注意判断pre！=NULL且pre->next!=NULL。

        在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

        具体代码如下：

typedef struct {
    int val;
    struct MyLinkedList *next;
    
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {
    //创建链表时就建立一个头结点
    MyLinkedList* head=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    head->next=NULL;
    return head;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
    //获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
    MyLinkedList *cur=obj->next;
    for(int i=0;cur!=NULL;++i){
        if(i==index){
            return cur->val;
        }else{
            cur=cur->next;
        }
    }
    return -1;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    //将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    MyLinkedList *cur=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    cur->val=val;//注意此时obj是虚头节点
    cur->next=obj->next;
    obj->next=cur;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    MyLinkedList *cur=obj;
    while(cur->next!=NULL){
        cur=cur->next;
    }
    MyLinkedList *temp=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    temp->val=val;
    temp->next=NULL;
    cur->next=temp;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    //将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
    if(index==0){
        myLinkedListAddAtHead(obj,val);
        return;
    }
    MyLinkedList *cur=obj->next;
    for(int i=0;cur!=NULL;++i){//此时cur指向下标为index的前一个节点
        if(i==index-1){
          MyLinkedList *temp=(MyLinkedList*)malloc(sizeof(MyLinkedList));
          temp->val=val;
          temp->next=cur->next;
          cur->next=temp;
        }else{
            cur=cur->next;
        }
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    //如果下标有效，则删除链表中下标为 index 的节点。
    if (index == 0){
        MyLinkedList *tmp = obj->next;
        if (tmp != NULL){
            obj->next = tmp->next;
            free(tmp);     
        }
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i=1;cur!=NULL&&cur->next!=NULL;i++){//此时cur指向index的前一个节点，注意判断条件
        if (i==index){
            MyLinkedList *tmp=cur->next;
            if (tmp!=NULL) {//进行删除操作前要判断是否是空指针
                cur->next = tmp->next;
                free(tmp);
            }
            return;
        }
        else{
            cur = cur->next;
        }
    }
}

void myLinkedListFree(MyLinkedList* obj) {
    while(obj!=NULL){
        MyLinkedList *temp=obj;
        obj=obj->next;
        free(temp);
    }
}

206.反转链表

        题目：反转一个单链表。

        示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

        1.头插法

        添加一个虚头结点，不断取下后面节点进插入虚节点后面。

ListNode* reverseList(ListNode* head) {
        //头插法逆置链表
        ListNode *dum=new ListNode(0);
        ListNode *p=head;
        while(p!=nullptr){
            ListNode *nxt=p->next;
            p->next=dum->next;
            dum->next=p;
            p=nxt;
        }
        return dum->next;
    }

        2. 双指针法

        在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* pre=NULL;
    struct ListNode* cur=head;
    while(cur){
        struct ListNode* nxt=cur->next;
        cur->next=pre;
        pre=cur;
        cur=nxt;
    }
    return pre;
}

        3.递归法

        本质和双指针一样，每一次的操作都是改变指针指向与后移，注意停止的条件

struct ListNode* reverseList(struct ListNode* head) {
    if(head==NULL||head->next==NULL){
           return head;
       }
    struct ListNode* newhead=reverseList(head->next);
    head->next->next=head;
    head->next=NULL;
    return newhead;
}

21.合并两个有序链表

        使用归并思想，主要还是链表操作。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if(list1==NULL) return list2;
    if(list2==NULL) return list1;
    struct ListNode* dummy=malloc(sizeof(struct ListNode));
    struct ListNode* cur=dummy;
    while(list1!=NULL&&list2!=NULL){
        if(list1->val<list2->val){
            cur->next=list1;
            list1=list1->next;
        }else{
            cur->next=list2;
            list2=list2->next;
        }
        cur=cur->next;
    }
    if(list1) cur->next=list1;
    if(list2) cur->next=list2;
    return dummy->next;
}