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

今天的链表学习处于基础中的基础阶段，掌握链表的建立、增加、删除，操作时要密切关注相邻节点之间的关系。

LeetCode 203.移除链表元素

struct ListNode* removeElements(struct ListNode* head, int val){

    typedef struct ListNode ListNode;

    ListNode *vhead;

    vhead = (ListNode *)malloc(sizeof(ListNode));

    vhead->next = head;

    ListNode *cur = vhead;

    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 = vhead->next;

    free(vhead);

    return head;

}

一般来说我们都会用一个虚拟头结点指向实际的头结点去进行操作，删除操作最重要的就是明白删除其实就是把前一个节点的指针域中的指针指向后一个节点的地址 ，此刻因为直接指向后一个节点的时候我们要删除的节点就会跑丢，无法进行空间释放，这样可能会导致一些不好的情况发生，因此我们一般用一个临时的指针提前指向需要删除的节点，在前后节点连接起来之后，将这个临时指针指向的空间进行释放。

LeetCode 707.设计链表

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;

    int i = 0;

    while (cur != NULL)

    {

        if (i == index)

        {

            return cur->val;

        }else {

            cur = cur->next;

        }

        i++;

    }

    return -1;

}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {

    MyLinkedList *vhead = (MyLinkedList*)malloc(sizeof(MyLinkedList));

    vhead->val = val;

    vhead->next = obj->next;

    obj->next = vhead;

}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {

    MyLinkedList* cur = obj;

    while (cur->next != NULL)

    {

        cur = cur->next;

    }

    MyLinkedList* vhead = (MyLinkedList*)malloc(sizeof(MyLinkedList));

    vhead->val = val;

    vhead->next = NULL;

    cur->next = vhead;

}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {

    if (0 == index)

    {

        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);

    }

}

链表的设计是基础中的基础，这个后期可以理解性多写写，直到就像我们写1+1=2这样熟悉为止。

LeetCode 206反转链表

struct ListNode* reverseList(struct ListNode* head){

    struct ListNode* pre = NULL;

    struct ListNode* tmp;

    while (head)

    {

        tmp = head->next;

        head->next = pre;

        pre = head;

        head = tmp;

    }

    return pre;

从第一个节点开始，通过一个临时节点保存第二个节点的地址，让第一个节点的指针域指向初始化为空的pre节点 ，此时第一个节点便指向了空，也就是成为了新链表的尾节点，让指针pre指向head指向的地址，让head指向临时指针也就是节点二的地址；循环执行，返回最后的pre指针。