代码修炼Day3_LeetCode203移除链表元素&707设计链表&206翻转链表

代码修炼Day3_LeetCode203移除链表元素&707设计链表&206翻转链表

题目链接：

力扣203移除链表元素

解题思路：

单链表删除节点，先找到需删除节点的前节点，将前节点直接指向该节点的后节点进行删除

代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //判断头结点是否需要删除
        while(head != NULL && head->val == val ){
            ListNode *tmp = head;
            head = head -> next;
            delete tmp;
        }

        //判断非头结点是否需要删除
        ListNode *p = head;
        while(p != NULL && p->next != NULL ){
            if(p->next->val == val){
                ListNode *tmp = p->next;
                p->next = p->next->next;
                delete tmp;
            }else{
                p = p->next;
            }
        }
        return head;
    }
};

此算法直接对原链表进行修改，可优化，设置虚头结点，方便统一操作

代码：

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

复杂度分析：

时间复杂度：O(n)
空间复杂度：O(1)

其他解法：

递归，后面补代码

题目链接：

力扣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的节点的值
    int get(int index) {
        if(index < 0 || index > (_size - 1)){
            return -1; //下标无效，返回-1
        }
        LinkedNode *cur = _dummyHead->next; //指向首元结点
        while(index--){ //index不为零时，cur右移；index为零，不执行
            cur = cur->next;
        }
        return cur->val; //返回cur的值
    }
    
    //在第一个元素前插入一个值为val的节点
    void addAtHead(int val) {
        LinkedNode *newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    //在最后一个元素后插入一个值为val的节点
    void addAtTail(int val) {
        LinkedNode *newNode = new LinkedNode(val);
        LinkedNode *cur =_dummyHead; //注意是虚拟节点,不是_dummyHead->next首元结点
        while(cur->next != nullptr){ //next不是空指针，则右移；next为空，代表已到最后节点
            cur = cur->next;
        }
        cur->next = newNode; //定义结构体时，已经定义next为nullptr
        _size++;
    }
    
    //在index(合法)前插入一个值为val的节点,index大于size非法
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index < 0) index = 0;
        LinkedNode *newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead; //注意是虚拟节点,不是_dummyHead->next首元结点
        while(index--){ //index不为零时，cur右移；index为零，不执行
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    //删除下标为index（合法）的节点
    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--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }

private:
    int _size;
    LinkedNode* _dummyHead;
};
 

双向链表设计

设计思路一样，但更繁琐，后面补代码

题目链接：

力扣206反转链表

解题思路：

翻转链表可以直接使用双指针来改变指针方向

代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head; //记录当前需要翻转方向的节点
        ListNode* pre = NULL; //翻转节点前的节点
        ListNode* temp; //记录需要继续翻转的位置
        while(cur){ //cur非空，需要进行翻转
            temp = cur->next; //记录下一个节点位置，防止丢失
            cur->next = pre; //翻转
            pre = cur; //右移一位
            cur = temp; //右移一位
        }
        return pre; //while结束后，cur为空，pre指向最右边元素；此时完成翻转，自右向左输出
    }
};

复杂度分析：

时间复杂度：O(n)，需要将链表遍历一遍
空间复杂度：O(1)

其他解法

递归，后面补代码