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

203移除链表元素

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

解题思路

• 直接删除法：直接使用原来的链表进行删除操作，需要注意的是移除头节点和非头节点使用的方式不同（因为移除节点时需要找到该节点的前一个节点，而头节点没有前一个节点）。移除头节点是将头节点head向后移一位，移除其他节点则是将该节点的上一位指向该节点的后一位，使用C/C++的小伙伴们不要忘记清理节点内存哦。
• 虚拟节点法：设置一个虚拟节点，令其为头节点，接下来就可以用移除其他节点的方法来移除任意节点了（包括头节点）。
• 两种方式的时间复杂度: O(n)，空间复杂度: O(1)

遇到的问题

对虚拟节点法的代码还需多多理解，尽力掌握

代码实现

直接删除法（C语言版）

struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* t;   //暂时保存需要删除的节点，以便在删除该节点后释放其内存空间
    while(head && head->val == val){
        t = head;
        head = head -> next;    //将新的头结点设置为head->next并删除原来的头结点
        free(t);
    }
    struct ListNode* cur = head;
    while(cur && (t = cur -> next)){       //cur cur->next均不为空
        if(t->val == val){
            cur->next=t->next;  //将cur->next设置为cur->next->next并删除cur->next
            free(t) ;  
        }
        else{
            cur = cur->next;  //下一个
        }  
    }
    return head;
}

虚拟节点法（C语言版）

struct ListNode* removeElements(struct ListNode* head, int val) {
    // 定义别名简化结构体类型的使用
    typedef struct ListNode ListNode;
    // 创建一个新的头节点 shead，并将其指向原始头节点 head
    ListNode *shead;
    shead = (ListNode *)malloc(sizeof(ListNode));
    shead->next = head;
    // 将 cur 指针指向新的头节点 shead
    ListNode *cur = shead;
    // 遍历链表，查找并删除值为 val 的节点
    while (cur->next != NULL) {
        // 如果下一个节点的值等于 val，则删除这个节点
        if (cur->next->val == val) {
            // 临时保存需要删除的节点
            ListNode *tmp = cur->next;
            // 跳过当前节点，直接连接到下一个节点，以实现删除操作
            cur->next = cur->next->next;
            // 释放之前保存的节点的内存空间
            free(tmp);
        } else {
            // 如果下一个节点的值不等于 val，则继续遍历
            cur = cur->next;
        }
    }
    // 更新头节点指针为去除了值为 val 的节点后的链表头部
    head = shead->next;
    // 释放新的头节点的内存空间
    free(shead);
    // 返回更新后的头节点指针
    return head;
}

总结

单链表删除节点时需要注意删除头节点和删除其他节点的方式是不一样的，要想统一起来则需要使用虚拟节点法。

707.设计链表

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

解题思路

• 获取链表第index个节点的数值
• 在链表的最前面插入一个节点
• 在链表的最后面插入一个节点
• 在链表第index个节点前面插入一个节点
• 删除链表的第index个节点

遇到的问题

• 整个都是陌生中夹杂着熟悉，无从下手。。。
• 还需多多理解这个题

代码实现

C语言版

typedef struct MyLinkedList {
    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) {
    // 获取指定索引位置的节点值
    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) {
    // 在链表头部插入节点
    MyLinkedList *nhead = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    nhead->val = val;
    nhead->next = obj->next;
    obj->next = nhead;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    // 在链表尾部添加节点
    MyLinkedList *cur = obj;
    while(cur->next != NULL){
        cur = cur->next;
    }
    MyLinkedList *ntail = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    ntail->val = val;
    ntail->next = NULL;
    cur->next = ntail;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    // 在指定位置插入节点
    if (index == 0){
        myLinkedListAddAtHead(obj, val);
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL; i++){
        if (i == index){
            MyLinkedList* newnode = (MyLinkedList *)malloc(sizeof (MyLinkedList));
            newnode->val = val;
            newnode->next = cur->next;
            cur->next = newnode;
            return;
        }
        else{
            cur = cur->next;
        }
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int 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++){
        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 *tmp = obj;
        obj = obj->next;
        free(tmp);
    }
}

总结

基本覆盖了链表的常见操作，对练习链表操作有很大帮助

206.反转链表 

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

解题思路

• 双指针法：定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null；把 cur->next 节点用tmp指针保存一下，然后开始反转，将cur->next 指向pre，更新pre和cur指针；用循环一个个进行反转即可，直到cur 指针指向null，然后return pre。时间复杂度: O(n)，空间复杂度: O(1)
• 递归法：递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。但更晦涩难懂。时间复杂度: O(n)，空间复杂度: O(n)

代码实现

双指针法（C语言版）

struct ListNode* reverseList(struct ListNode* head){
    //保存cur的下一个结点
    struct ListNode* temp;
    //pre指针指向前一个当前结点的前一个结点
    struct ListNode* pre = NULL;
    //用head代替cur，也可以再定义一个cur结点指向head。
    while(head) {
        //保存下一个结点的位置
        temp = head->next;
        //翻转操作
        head->next = pre;
        //更新结点
        pre = head;
        head = temp;
    }
    return pre;
}

递归法（C语言版）

struct ListNode* reverse(struct ListNode* pre, struct ListNode* cur) {
    if(!cur)
        return pre;
    struct ListNode* temp = cur->next;
    cur->next = pre;
    //将cur作为pre传入下一层
    //将temp作为cur传入下一层，改变其指针指向当前cur
    return reverse(cur, temp);
}

struct ListNode* reverseList(struct ListNode* head){
    return reverse(NULL, head);
}

总结

这道题只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表，可用双指针法和递归法实现。

今日总结

知识部分进脑，还需多多努力，希望迟早能感受到刷题的快乐