【无标题】

小白算法记录Day3|203. 移除链表元素、707.设计链表、206.反转链表

一、LeetCode 203. 移除链表元素

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

题目描述：给你一个链表的头节点 head和一个整数 val ，请你删除链表中所有满足 Node.val == val的节点，并返回新的头节点 。

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

解题思路

本题是简单的删除链表元素，可以采用两种解法，一种是直接在原链表上进行删除，但是要考虑到头节点对应的值等于val的情况，故本题采用另一种思路，虚拟头节点的解法，在头节点前虚拟出一个节点方便我们删除头节点的操作。

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 *temp = cur->next;
            cur->next = cur->next->next;
            free(temp);
        }
        else{
            cur = cur->next;
        }
    }
    head = shead->next;
    free(shead);//释放虚拟节点
    return head;
}

二、LeetCode 707.设计链表

题目链接：707.设计链表
题目描述：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

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

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

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

解题思路

本题是建立链表接口函数，必须使用虚拟头指针法

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) {
    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 *temp = obj->next;
        if (temp != NULL) {
            obj->next = temp->next;
            free(temp);
        }
        return ;
    }

    MyLinkedList *cur = obj->next;
    for (int i = 1 ; cur != NULL && cur->next != NULL ; i++) {
        if (i == index) {
            MyLinkedList *temp = cur->next;
            if (temp != NULL) {
                cur->next = temp->next;
                free(temp);
            }
            return ;
        }
        else {
            cur = cur->next;
        }
    }
}

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

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

心得

Get创建函数中只是创建了头节点，而以下定义cur均是虚拟出的头节点obj的下一个节点，Get函数中i和cur是一致的，cur和i均是从第一个结点开始往后算，而另外的两个cur在i的前一个节点；

三、LeetCode 206.反转链表

题目链接：206. 反转链表

题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

解题思路

创建一个空指针，然后定义头节点和头节点的下一个节点，头节点指针指向最前面的空指针，此节点指向头节点，依次完成整个链表的反转。

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

总结

本题并不难，重点是理解定义空指针和头两个节点以及反转顺序。