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

LeetCode203.移除链表元素：203. 移除链表元素 - 力扣（Leetcode）

1.利用虚拟节点移除链表头结点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //利用虚拟结点
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(dummyHead != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;

    }
};

2.直接使用原来链表进行移除操作

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //删除头结点，为什么不用if
        while(head != NULL && head->val == val){
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }
        ListNode* cur = head;
        while(head != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;    //将当前要删除的节点放在temp中
                cur->next = cur->next->next;   //将cur->next指向它的下一个节点
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }

LeetCode707.设计链表 ：707. 设计链表 - 力扣（Leetcode）

分析：

注：引入临时指针cur,让cur在链表上移动，当前节点为cur，那么当前节点指向下一个节点的指针为 cur->next。cur的初始值：cur = dummyhead 或者 cur = dummyHead->next.

dummyHead和新节点newNode都是new出来的

采用虚拟头节点的方式设计链表： 

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

    先判断index是否合法（即index是否小于0或者大于size-1，size-1即最大索引）

    其次，让cur指向索引为index的节点，返回cur->next。

• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

    首先明确，链表的第一个元素使head，插入节点，链表的head产生变化。

注意：在添加新节点newNode的时候，首先确定新节点的指向，即newNode->next；再确定新节点前一个节点的指向，即cur->next.

• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

首先，找到链表的最后一个元素，标志为：cur->next为空，此时cur指向最后一个元素。

其次，在尾部添加一个新节点，令cur-next指向新节点，即cur->next = newNode。

• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

    在链表指定节点前添加节点，与get（index）相同，要判断index是否合法，index小于0时，在头节点前添加节点，即index=0。

    其次，找到index-1节点，并让cur指向该节点。第0节点是head节点，不是dummyHead节点。

 添加新节点newNode：先确定newNode->next = cur->next，再确定cur->next = newNode。

注意：上述增加新节点的操作，在完成后要让链表长度+1；同理，完成删除节点操作后，要让链表长度-1.

• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

    找到index的前一个节点，并令cur指向该节点。

    其次，令cur->next指向删除节点 的后一个节点，即cur->next = cur->next->next.

    在完成指针指向后，要删除index节点的内存，使用delete命令，在为删除前利用一个临时指针temp指向index，完成删除后执行 delete temp释放内存，同时要令temp=NULL，防止temp变成野指针。 

class MyLinkedList {
public:
    //定义链表节点结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(NULL){}
    };
    MyLinkedList() {
        my_dummyHead = new LinkedNode(0);
        my_size = 0;
    }
    
    int get(int index) {

        if(index > (my_size-1) || index < 0){
            return -1;
        }
        LinkedNode* cur = my_dummyHead->next;
        while(index--){
            cur = cur -> next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode -> next = my_dummyHead -> next;
        my_dummyHead -> next = newNode;
        my_size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* cur = my_dummyHead; //cur存储head的地址，即cur是指向head的指针
        while(cur -> next != NULL){
            cur = cur -> next;  //进行循环，找到指向最后一个节点的指针
        }
        LinkedNode* newNode = new LinkedNode(val);
        cur -> next = newNode;
        my_size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index  > my_size) return;
        if (index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = my_dummyHead;
        while(index--){
            cur = cur->next;  //结束后cur是指向索引为index的指针
        }
        newNode -> next = cur ->next;
        cur -> next = newNode;
        my_size++;
        
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >=my_size) return;
        LinkedNode* cur = my_dummyHead;
        while(index--){
            cur = cur -> next;
        }
        LinkedNode* temp = cur->next;// 指向想要删除的那部分内存
        cur->next = cur -> next->next;
        delete temp; //释放内存
        temp = NULL;//防止temp变为野指针
        my_size--;
    }
private:     //链表类中成员是链表大小和头结点
    int my_size;   //链表的长度
    LinkedNode* my_dummyHead;            //虚拟头结点
};

 LeetCode 206.反转链表: 206. 反转链表 - 力扣（Leetcode）

1.双指针解法

分析：利用两个指针pre和cur实现翻转操作，在进行更新时，先更新pre(pre = cur)，再更新cur(cur = temp)，顺序不能变。最后当cur指向NULL时，pre指向反转后的链表的head节点。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur != NULL){
            ListNode* temp = cur->next;
            cur->next = pre;  //翻转操作
            //更新操作
            pre = cur;
            cur = temp;
        }
        return pre;

    }
};

2.递归解法(不是特别理解)

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre; 
        //更新操作
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(NULL,head);

    }
};