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

题目链接：203.移除链表元素

看到这个题目，就可以想到可以采用双指针的方法，考虑到链表的特性，我们需要让两个指针一前一后，前面的指针去判断节点值是否为题目的目标，后面的指针负责将移除元素之后的各个节点链接起来，所以前面的指针需要遍历每一个节点。如果两个指针都指向第一个节点，考虑特殊情况，第一个节点的值就是删除的元素，这种情况下，我们删除第一个节点后，整个链表就断开了，所以我们可以添加个虚拟头节点在第一个节点前，让两个指针错开，后面的指针指向虚拟头节点，前面的节点指向第一个节点，然后遍历每个节点，就可以解决这个问题，代码如下：

struct ListNode* removeElements(struct ListNode* head, int val){
    if (head == NULL) {
        return NULL;
    }
    struct ListNode *H;
    H = (struct ListNode *)malloc(sizeof(struct ListNode));
    H->next = head;
    struct ListNode *q = head;
    struct ListNode *p = H;
    while (q != NULL) {
        if (q->val != val) {
            p = p->next;
            q = q->next;
        } else {
            p->next = q->next;
            q = q->next;
        }
    }
    return H->next;
}

时间复杂度为O(N)

 题目链接：707.设计链表

这道题目就是考验基本功的能力，难在如何理清逻辑，写出代码，题目也有小陷阱，当我在调试的时候遇到了一个bug，出现在myLinkedListAddAtHead，这里需要注意的是，obj指针是通过值传递传进这个函数的，所以如果我们试图修改obj的值，其实主程序中的实参是不会改变的，我在myLinkedListAddAtHead函数里，试图改变obj的值，所以导致后面调试时一直通过不了，这里只有采用虚拟头节点的方式才能解决这个问题。代码如下：

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


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

int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList *p = obj->next;
    int i = index;
    if (i == 0) {
        if (p == NULL) {
            return -1;
        } else {
            return (p->val);
        }
    }
    while (i > 0) {
        p = p->next;
        if (p == NULL)
            return -1;
        i--;
    }
    return (p->val);
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList *node = (MyLinkedList *)malloc(sizeof(MyLinkedList));
    node->val = val;
    node->next = NULL;
    if (obj->next == NULL) {
        obj->next = node;
    } else {
        node->next = obj->next;
        obj->next = node;
    }
}

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

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    MyLinkedList *mylist = (MyLinkedList *)malloc(sizeof(MyLinkedList));
    mylist->val = val;
    mylist->next = NULL;
    MyLinkedList *p = obj;
    MyLinkedList *q = obj->next;
    int i = index;
    if (i == 0) {
        if (obj->next == NULL) {
            obj->next = mylist;
        } else {
            mylist->next = obj->next;
            obj->next = mylist;
        }
        return;
    }
    while (i > 0) {
        p = p->next;
        if (p == NULL)
            return;
        i--;
    }
    q = p->next;
    mylist->next= q;
    p->next = mylist;
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (obj->next == NULL)
        return;
    if (index == 0) {
        obj->next = obj->next->next;
        return;
    }
    MyLinkedList *q = obj->next;
    MyLinkedList *p = obj;
    int i = index;
    while (i > 0) {
        p = p->next;
        q = q->next;
        if (q == NULL)
            return;
        i--;
    }
    if (q->next == NULL) {
        p->next = NULL;
    } else {
        p->next = q->next;
    }
}

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

/**
 * Your MyLinkedList struct will be instantiated and called as such:
 * MyLinkedList* obj = myLinkedListCreate();
 * int param_1 = myLinkedListGet(obj, index);
 
 * myLinkedListAddAtHead(obj, val);
 
 * myLinkedListAddAtTail(obj, val);
 
 * myLinkedListAddAtIndex(obj, index, val);
 
 * myLinkedListDeleteAtIndex(obj, index);
 
 * myLinkedListFree(obj);
*/

也可以通过浏览代码随想录获得更为简短的代码。

题目链接：206.反转链表 

这是链表中一道比较基础的题目，可以首先建立一个虚拟头节点，然后将每个节点依次插入虚拟节点之后完成反转链表，代码给出如下：

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *H = (struct ListNode *)malloc(sizeof(struct ListNode));
    H->next = NULL;
    struct ListNode *p = head;
    struct ListNode *tmp = NULL;
    while (p != NULL) {
        tmp = p->next;
        if (H->next == NULL) {
            p->next = NULL;
        } else {
            p->next = H->next;
        }
        H->next = p;
        p = tmp;
    }
    tmp = H->next;
    free(H);
    return tmp;
}

虚拟头节点最后的时候需要free，释放掉。

今日总结：今天的题目总体来说比较简单，但需要非常仔细，逻辑清晰，特别是链表设计这一道题目，比较容易踩坑，虚拟头节点的妙处还要多多体会。接下来继续坚持加油吧！