LeetCode203.移除链表元素 707.设计链表 206.反转链表

LeetCode203.移除链表元素

思路：

方法一：直接使用原来的链表来进行删除操作

        1.如果删除的元素位于头结点，那么需要单独对头结点进行处理，让head = head->next；

        2.如果删除的元素位于非头结点，那么就需要判断当前结点指向的下一结点是否等于val；

代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //删除头结点
        while(head && head->val == val){//不断的判断当前头结点是否等于val，一旦head等于NULL或者head->val != val，则退出循环
                ListNode* temp = head;
                head = head->next;
                delete temp;

        }
        //删除非头结点
        ListNode* cur = head;//新建一个cur指针指向头结点，后续对cur操作就不会影响head，一旦将链表中等于val的元素删除完后，直接返回val即可
        while(cur && cur->next){//cur不为空并且cur->next也不为空
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }else{
                cur = cur->next;
            }
        }
        return head;    
    }
};

方法二：设置一个虚拟头结点在进行删除操作

        设置一个虚拟头结点让其指向头结点，那么对头结点和非头结点的删除操作就是一样了。

代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* VirtualHead = new ListNode(0);// 设置一个虚拟头结点
        VirtualHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = VirtualHead;
        while(cur && cur->next){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }else{
                cur = cur->next;
            }
        }
        head = VirtualHead->next;
        delete VirtualHead;
        return head;
    }
};

LeetCode707.设计链表

思路：

        1.构建一个虚拟头结点，指向头结点，方便后续遍历和增删

        2.在第n个结点插入时，需要找到第n-1个结点的位置，通过cur指针指向虚拟头结点，然后while(n--)不断遍历，此时cur来到第n-1个结点的位置上；同理，删除第n个结点时也需要找到第n-1个结点的位置。

代码：

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    MyLinkedList() {
        dummyHead = new LinkedNode(0);
        size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index > size - 1){
            return -1;
        }
        LinkedNode* cur = dummyHead;
        cur = cur->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = dummyHead;
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* cur = dummyHead;
        while(cur->next != NULL){
            cur = cur->next;
        }
        LinkedNode* newNode = new LinkedNode(val);
        cur->next = newNode;
        newNode->next = NULL;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > size) return;
        if(index < 0) index = 0;
        LinkedNode* cur = dummyHead;
        LinkedNode* newNode = new LinkedNode(val);
        //经过while循环后，cur来到index - 1的位置，cur->next指向index位置
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        LinkedNode* cur = dummyHead;
        while(index--){
            cur = cur->next;
        }
        LinkedNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        size--;
    }
    void printLinkedList(){
        LinkedNode* cur = dummyHead;
        while(cur->next != NULL){
            cout<< cur->next->val <<" ";
            cur = cur->next;
        }
        cout<< endl;
    }
    private:
        int size;
        LinkedNode* dummyHead;
};

LeetCode206.反转链表

思路：

双指针：定义pre指向前一个结点，cur指向当前结点，再用一个temp保存cur->next下一个结点，防止cur找不到下一个结点 ，最后返回pre就是反转后的头结点。

代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = NULL;
        ListNode* temp;
        while(cur){
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};