刷题打卡day3：203.移除链表元素 ● 707.设计链表 ● 206.反转链表

203.移除链表元素

// 单链表
struct ListNode {
	int val;  // 节点上存储的元素
	ListNode* next;  // 指向下一个节点的指针
	ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

class Solution {
public:
    ListNode* removeElements(ListNode* head, int target) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;//设置虚拟头结点
        ListNode* cur = dummyhead;//开始设置为虚拟头结点
        //遍历所有节点
        while(cur->next != NULL)
        {
            //删除节点时采用前一个节点进行操作!
            if(cur->next->val == target)
            {
                ListNode* tmp = cur->next;//创建临时节点 = 要删除的那个节点
                cur->next = cur->next->next;//当前节点的下一个=下一个的下一个
                delete tmp;//c++用完要delete
            }
            //不需要删除节点就一直向下遍历
            else
                cur = cur->next;
        }
        //将设置的虚拟头结点清除
        head = dummyhead->next;
        delete dummyhead;
        return head;
        

    }
};

707.设计链表

class MyLinkedList {
public:

    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    //构造函数初始化
    MyLinkedList() {
        dummyhead = new LinkedNode(0);
        size = 0;
    }

    //获取链表中第 index 个节点的值。如果索引无效，则返回-1。
    int get(int index) {
        if (index > (size - 1) || index < 0)
            return -1;
        LinkedNode* cur = dummyhead->next;
        while(index--)
        {
            cur = cur->next;
        }
        return cur->val;
    }
    
    //在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
    void addAtHead(int val) {
        LinkedNode* newnode = new LinkedNode(val);
        newnode->next = dummyhead->next;
        dummyhead->next = newnode;
        size ++;
    }
    
    //addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
    void addAtTail(int val) {
        LinkedNode* newnode = new LinkedNode(val);
        LinkedNode* cur = dummyhead;
        while(cur->next != nullptr)//不是最后一个，就一直遍历
        {
            cur = cur->next;
        }//遍历完之后，现在cur指向尾部节点了
        cur->next = newnode;
        size ++;   
    }
    
    //在链表中的第 index 个节点之前添加值为 val 的节点
    //如果 index 等于链表的长度，则该节点将附加到链表的末尾
    //如果 index 大于链表长度，则不会插入节点。
    //如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {
        if (index > size || index < 0) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = dummyhead;
        ///要操作他，一定要让cur指向之前的节点。只有知道插入节点的前一个节点，才能进行插入操作
        //保证第index个节点是cur->next，这样才能进行插入操作
        while(index--) {
            cur = cur->next;//找到index就不执行了这个了，使得cur指向index的前一个节点
        }  
        newNode->next = cur->next;//说实话，买看懂。为啥是在后面
        cur->next = newNode;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        LinkedNode* cur = dummyhead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        size--;

    }

private:
    int size;
    LinkedNode* dummyhead;
};

206.反转链表 

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