代码随想录day3 || 203.移除链表元素、707.设计链表、206.反转链表

203、移除链表元素
707、设计链表
206、反转链表

203、移除链表元素

解题思路：

此题删除链表中元素是很简单的，只需要让待删节点之前一个节点指向待删节点之后一个节点即可。此题最大的问题就是，题目要求我们要返回新链表中的头结点，如果我们就采用仅仅复制头结点的方式(用H=head)然后用H进行操作，最后返回head。这样就会导致如果头结点也是我们需要删除的节点就会导致错误。

一、直接使用原来的链表操作

我们可以采用循环操作判断第一个不是我们要删除的节点。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头结点
        ListNode* cur = head;
        while (cur != NULL && cur->next!= NULL) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

二、设置虚拟头结点

创建一个新节点来作为整个链表的头结点，该节点中的值没有意义，只是用该节点来方便我们的操作。如果用H->next=head; 此时 我们操作H的话就把原先的头结点当做了一个普通节点来操作，此时原先的头结点就可以被删除了。最后返回H->next就满足条件了

// 设置一个虚拟头结点来解决
 class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* p = new ListNode;
        p->next = head;
        head = p;
        while(head && head->next){
            if(head->next->val == val)
                head->next = head->next->next;
            else
                head = head->next;
        }
        return p->next;
    }
};

最后，return头结点的时候，应该是 return p->next

707、设计链表

解题思路
这道题目设计链表的五个接口：

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

链表有几种：单向链表、双向链表、循环链表
循环链表：将单链表中最后一个节点的指针域指向头节点（带头结点的链表）或首元节点（不带头节点的链表），使整个单链表形成一个首尾相连的环。

双向链表：链表中每个节点有两个指针域，一个指向直接前趋，一个指向后继，构成一个双向的链表。

单向链表

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


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

int myLinkedListGet(MyLinkedList* obj, int index) {
    if (index < 0){
        return -1;
    }

    int i = 0;
    MyLinkedList* p = obj->next;

    while(p && i < index){
        p = p->next;
        i++;
    }

    if(p){
        return p->val;
    }else{
        return -1;
    }
}

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

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

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if(index <= 0 ){
        myLinkedListAddAtHead(obj,val);
        return;
    }
    MyLinkedList *p=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    p->val = val;
    int i = 0;
    MyLinkedList *q = obj->next;
    while(q && i < index-1){
        i++;
        q = q->next;
    }

    if(q && i == index-1){
        p->next = q->next;
        q->next = p;
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    int i = 0;
    MyLinkedList *q = obj;
    while(q -> next && i < index){
        i++;
        q = q->next;
    }
    if(i == index && q->next){
        MyLinkedList *p = q->next;
        q->next = p->next;
        free(p);
    }
}

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

206、反转链表

解题思路

一、双指针

思路：
首先定义一个cur指针，指向头节点，再定义一个pre指针，pre在前cur在后。每次让pre值赋给cur的next，实现一次局部反转， 然后pre和cur同时向前移动一个位置也就是pre到cur的位置，cur到cur->next的位置。直到cur == nil，这时候pre就是新链表的头节点。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

二、递归法

基线条件：空链或只有一个结点，直接返回头指针
递归条件：递归调用，返回子链表反转后的头指针

假设整个链表有N个节点，要将整个链表反转，可以先将除第一个元素外的剩下N-1个元素先反转，再把第一个元素插入到剩下链表的末尾。再将问题往下细分，直到遇到空节点。要注意到异常情况（链表为空或只有一个或两个节点）。

Solution {
public:
    ListNode* reverseList(ListNode* head) {
    
        if (head == NULL || head->next == NULL)     // 空链或只有一个结点，直接返回头指针
        {
            return head;            
        }

        else                                        // 有两个以上结点
        {
            ListNode *new_head = reverseList(head->next); // 反转以第二个结点为头的子链表
            
            // head->next 此时指向子链表的最后一个结点
            
            // 将之前的头结点放入子链尾
            head->next->next = head;
            head->next = NULL;
            
            return new_head;
        }
    }
};