代码随想录算法训练营第三天|LeetCode 230.移除链表元素、707.设计链表、206.反转链表

LeetCode 230.移除链表元素

题目链接

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* myHead = new ListNode(0); // 虚拟头结点，指向给定head，作头结点，值为空
        myHead->next = head;
        ListNode* cur = myHead;
        while(cur->next != nullptr) { 
            if(cur->next->val == val) {
                // 如果当前节点的写一个节点值等于val，则进行删除
                ListNode* temp = cur->next;
                cur->next = temp->next;
                delete temp;
            } else {
                cur = cur->next;
            }
            
        }
        head = myHead->next;
        delete myHead;
        return head;
    }
};

LeetCode 707.设计链表

题目链接

class MyLinkedList {

public:
    struct ListNode {
        int val;
        ListNode* next;
        ListNode(int val):val(val), next(nullptr) {}
    };
    
    // 构造函数初始化
    MyLinkedList() {
        dHead = new ListNode(0);
        listSize = 0;
    }
    
    // 获取下标为index的节点的值
    int get(int index) {
        if(index >= listSize || index < 0) { // listSize表示链表的节点个数，例如，若有两个元素，下标则为0、1，listSize为2，若index为2，则返回-1，若index为1，则能正常返回; index小于0为非法下标。
            return -1;
        }
        ListNode *cur = dHead->next;
        while(index > 0) { // 如果下标大于0，则将指针往后移，因为当前指针指向了链表的第一个节点，若index=0，则不进入循环，直接返回cur->val
            cur = cur->next;
            index --;
        }
        return cur->val;
    }
    
    // 将一个值为val的节点追加到链表中作为链表的最后一个元素
    void addAtHead(int val) {
        ListNode *node = new ListNode(val);
        // 头插法
        node->next = dHead->next;
        dHead->next = node;
        listSize ++;
    }
    
    // 将一个值为val的节点追加到链表中作为链表的最后一个元素
    void addAtTail(int val) {
        ListNode *node = new ListNode(val);
        ListNode *cur = dHead; // 用于迭代链表
        while(cur->next != nullptr) { // nullptr是空指针
            cur = cur->next;
        }
        // 此时的cur指向链表的最后一个节点
        cur->next = node;
        listSize ++;
    }
    
    // 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
    void addAtIndex(int index, int val) {
        ListNode *node = new ListNode(val);
        if(index == listSize) { // index等于链表长度时，在链表最后插入节点
            addAtTail(val);
        } else if(index < listSize && index >= 0) { // 此时插入的位置在链表中或表头
            ListNode *cur = dHead;
            // 需要找到插入的前一个位置
            while(index > 0) {
                cur = cur->next;
                index --;
            }
            node->next = cur->next;
            cur->next = node;
            listSize ++;
        } else {
            // 还有一种情况是index < 0，则删除新创建的节点
            delete node;
        }
    }
    
    // 如果下标有效，则删除链表中下标为 index 的节点
    void deleteAtIndex(int index) {
        if(index <= listSize - 1 && index >= 0) {
            // 合法下标
            ListNode *cur = dHead;
            // 要找到要删除下标的前一个节点
            while(index > 0) {
                cur = cur->next;
                index --;
            }
            ListNode *temp = cur->next;
            cur->next = temp->next;
            listSize --;
            delete temp;
        }
    }
    
// 私有化成员
private:
    int listSize; // 链表的节点数量
    ListNode *dHead; // 链表的头节点，指向链表的第一个节点
};

LeetCode 206.反转链表

题目链接

头插法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 若为空链表，返回原链表
        if(head == nullptr) {
            return head;
        }
        // 采用虚拟头结点，使用头插法实现链表逆置
        ListNode* dHead = new ListNode(0);
        dHead->next = nullptr;
        while(head != nullptr) {
            ListNode* cur = head;
            head = head->next;
            cur->next = dHead->next;
            dHead->next = cur;
        }
        return dHead->next;
    }
};

双指针法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 双指针法
        ListNode* temp; // 保存下一个节点
        ListNode* cur = head; // 当前指针
        ListNode* pre = nullptr; // 保存新链表头
        while(cur != nullptr) {
            temp = cur->next; // 保存原链表
            cur->next = pre; // 开始逆置，是cur成为新链表头
            pre = cur; // 让pre指向新链表头
            cur = temp; // cur指向原链表，进行迭代
        }
        return pre;
    }
};