代码随想录训练营第三天| 203.移除链表元素 707.设计链表 206.反转链表

Leetcode 203.移除链表元素

题目链接  203. 移除链表元素 - 力扣（LeetCode）

解题思路  

1. 删除头结点时另做考虑（由于头结点没有前一个结点）。

2. 设置一个虚拟头结点，删除头结点就不用另做考虑，直接可以删除。

代码实现

1.考虑头结点的一般方法

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* temp;          //定义一个新的指针
    while(head&&head->val==val)
    {
        temp = head;                  //新指针指向头结点
        head = head->next;            //保持头结点的指针性质不变
        free(temp);
    }

    struct ListNode* node = head;     
    while(node&&temp==node->next)     //头结点存在且temp指向下一个节点
    {
        if(temp->val==val)
        {
            node->next = temp->next;
            free(temp);
        }
        else
        {
            node = node->next;
        }
    }
    return head;
}

2.设置虚拟节点的方法  

通过Carl老师的文章讲解，对虚拟节点理解和掌握

「代码随想录」链表基础操作 | 203.移除链表元素 - 移除链表元素 - 力扣（LeetCode）

struct ListNode* removeElements(struct ListNode* head, int val){
    typedef struct ListNode ListNode;
    ListNode *shead;
    shead = (ListNode *)malloc(sizeof(ListNode));
    shead->next = head;
    ListNode *cur = shead;
    while(cur->next != NULL){
        if (cur->next->val == val){
            ListNode *tmp = cur->next;
            cur->next = cur->next->next;
            free(tmp);
        }
        else{
            cur = cur->next;
        }
    }
    head = shead->next;
    free(shead);
    return head;
}

总结

1.直接使用原来的链表来进行删除操作。

2.设置一个虚拟头结点在进行删除操作。

Leetcode  707.设计链表

题目链接

707. 设计链表 - 力扣（LeetCode）

解题思路  

本身其实原理是很简单的，也不涉及算法。但是很容易错，尤其是C语言，非常容易出错。
作为一个刷题小白，还需要多刷几遍才可以。

代码实现

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


MyLinkedList* myLinkedListCreate() {
    MyLinkedList *p=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    p->next=NULL;
    return p;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
    if(index<0){
        return -1;
    }

    int i=0;
    MyLinkedList*p=obj->next;

    while(p && i<index){
        p=p->next;
        i++;
    }

    if(p){
        return p->val;
    }else{
        return -1;
    }
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList *p=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    p->next=obj->next;
    p->val=val;
    obj->next=p;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList *p=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    p->next=NULL;
    p->val=val;
    MyLinkedList *q=obj;
    while(q->next){
        q=q->next;
    }
    q->next=p;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if(index<=0){
        myLinkedListAddAtHead(obj,val);
        return;
    }
    MyLinkedList *p=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    p->val=val;
    //找第index-1个元素
    int i=0;
    MyLinkedList *q=obj->next;
    while(q && i<index-1){
        i++;
        q=q->next;
    }

    if(q && i==index-1){
        p->next=q->next;
        q->next=p;
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    int i=0;
    MyLinkedList *q=obj;
    while(q->next&&i<index){
        i++;
        q=q->next;
    }
    if(i==index && q->next){
        MyLinkedList *p=q->next;
        q->next=p->next;
        free(p);
    }
}

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

总结

需要注意以下问题：

1.内存分配与释放

2.链表的遍历

3.第0个和最后一个节点怎么处理

4.链表构造，怎么挂链

Leetcode 206.反转链表

题目链接

206. 反转链表 - 力扣（LeetCode）

解读思路

双指针法：首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。然后就要开始反转首先要把 cur->next 节点用temp指针保存一下，也就是保存一下这个节点。为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。

代码实现

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

}

总结

本题不仅用双指针还可以用递归法来解题。递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。讲解视频帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili