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

203.移除链表元素

题目链接：https://leetcode.cn/problems/remove-linked-list-elements/description/

注意：单链表只能遍历删除，删除结点需要知道该结点的前驱结点
若不想单独处理头结点或者链表没有头结点，可以自己定义一个虚拟头结点head，head->next指向当前链表的头结点或者第一个结点，注意返回时要返回head->next

//在原链表进行操作
struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* temp;//辅助结点
    // 当头结点存在并且头结点的值等于val时
    while(head&&head->val==val){
        temp=head;
        head=head->next; //更新头结点
        free(temp);//释放之前的头结点
    }
    struct ListNode* pre=head;
    //单链表中删除某个结点，需要找到它的前驱结点，因此用pre表示该结点的前驱结点，pre->next表示当前结点，便于进行删除操作
    while(pre){
        if(pre->next && pre->next->val==val){
            temp=pre->next;
            pre->next=pre->next->next;
            free(temp);
        }else
            pre=pre->next;
    }
    return head;
}

//使用虚拟头结点
struct ListNode* removeElements(struct ListNode* head, int val) {
    typedef struct ListNode ListNode;
    ListNode* temp,*shead;
    shead=(ListNode*)malloc(sizeof(ListNode));
    shead->next=head;
    struct ListNode* pre=shead;
    while(pre){
        if(pre->next && pre->next->val==val){
            temp=pre->next;
            pre->next=pre->next->next;
            free(temp);
        }else
            pre=pre->next;
    }
    head=shead->next;//更新头结点并删除虚拟头结点
    free(shead);
    return head;
}

707.设计链表

题目链接：https://leetcode.cn/problems/design-linked-list/description/

思路：使用带头结点的单链表，头结点的数据域记录链表长度

注意在插入和删除操作时，要先找到其前驱结点，才方便进行相应操作

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

MyLinkedList *myLinkedListCreate() {
   MyLinkedList *obj = (MyLinkedList *) malloc(sizeof(MyLinkedList));
    obj->val = 0;//初始化头结点的数据域，表示链表长度为0
    obj->next = NULL;
    return obj;//返回头结点
}
int myLinkedListGet(MyLinkedList *obj, int index) {
    MyLinkedList *p = obj->next;
    int i = 0;
    if (index < 0 || index > obj->val - 1) { //位置合法性检查
        return -1;
    }
    while (i < index) {
        p = p->next;
        i++;
    }
    return p->val;
}

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

void myLinkedListAddAtTail(MyLinkedList *obj, int val) {
    MyLinkedList *p, *r;
    p = obj;
    while (p) {//循环遍历寻找尾结点
        if (p->next == NULL) { //找到尾结点并插入新结点
            r = (MyLinkedList *) malloc(sizeof(MyLinkedList));
            r->val = val;
            p->next = r;
            r->next = NULL;//注意新的尾结点next要指向NULL
            obj->val++;
            break;
        }
        p = p->next;
    }
}

void myLinkedListAddAtIndex(MyLinkedList *obj, int index, int val) {
    if (index > obj->val || index < 0) return;
    obj->val++;
    MyLinkedList *p = obj, *s;
    for (int i = 0; i < index; i++) { //寻找插入位置的前驱结点，所以不是i<=index
        p = p->next;
    }
    s = (MyLinkedList *) malloc(sizeof(MyLinkedList));
    s->val = val;
    s->next = p->next;
    p->next = s;
}

void myLinkedListDeleteAtIndex(MyLinkedList *obj, int index) {
    if (index >= obj->val || index < 0) return;
    obj->val--;
    MyLinkedList *p = obj, *s;
    for (int i = 0; i < index; i++) { //寻找删除位置的前驱结点，所以不是i<=index
        p = p->next;
    }
    s = p->next;
    p->next = p->next->next;
    free(s);
}

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

206.反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/description/
题目描述：

思路

1.头插法

要反转链表，那么按头插法建立链表即可

struct ListNode* reverseList(struct ListNode* head) {
   typedef struct ListNode ListNode;
   ListNode *p，*temp;
   p=(ListNode*)malloc(sizeof(ListNode));//虚拟头结点
   p->next=NULL;
   while(head){
       temp=head->next;//辅助结点保存下一个结点
       head->next=p->next;
       p->next=head;
       head=temp;
   }
   return p->next;
}

2.双指针迭代-不需要定义新的链表

在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前驱结点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

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

3.递归

逻辑与双指针的逻辑相同，只不过把两个结点交换顺序的方法用递归来实现

//代码一
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);
}
//代码二
struct ListNode* reverseList(struct ListNode* head) {
    // 链表为空时直接返回，链表不为空则到返回最后一个节点
    if (head == NULL || head->next == NULL) {
        return head;
    }
    // 递归调用，翻转第二个节点开始往后的链表
    // newHead先指向最后一个节点，注意此时参数是倒数第二个节点
    // 这一步很精妙，每一次newHead都是指向空指针（链表为空）或保留在原链表中的最后一个节点（链表不空），作用就是返回新的头结点
    struct ListNode* newHead = reverseList(head->next);
    // 最后一个节点指向倒数第二个节点，翻转头节点与第二个节点的指向
    head->next->next = head;
    // 倒数第二个节点的下一节点置空。此时倒数第三个节点仍指向倒数第二个节点，下一次递归中将倒数第二个节点下一节点指向倒数第三个节点，不断重复这一过程
    // 此时的 head 节点为尾节点，next 需要指向 NULL
    head->next = NULL;
    return newHead;
}