代码随想录Day3

代码随想录Day3

1.移除链表元素

题目

203. 移除链表元素 - 力扣（LeetCode）

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

• 列表中的节点数目在范围 [0, 104] 内

• 1 <= Node.val <= 50

• 0 <= val <= 50

思路

• 暴力，头节点移除按 head = head -> next; 方式删除， 普通节点移除按 cur -> next = cur - > next -> next; 方式删除。
• 设立虚拟头节点，统一按普通节点移除方式删除节点

代码

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); //虚拟头节点
        dummyHead -> next = head;
        ListNode* cur = dummyHead;
        while(cur -> next != nullptr) {
            if(cur -> next -> val == val) {
                ListNode* tmp = cur -> next;
                cur -> next = cur -> next -> next;
                delete tmp; //释放节点
            }
            else {
                cur = cur-> next;
            }
        }
        return dummyHead -> next;
    }
};

小结

• 注意C/C++中删除节点后，要释放该节点空间；
• 返回时注意返回虚拟头节点的next；

2.设计链表

题目

707. 设计链表 - 力扣（LeetCode）

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

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

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

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

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

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

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

提示：

• 0 <= index, val <= 1000

• 请不要使用内置的 LinkedList 库。

• get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

思路

• 设置虚拟头节点，完成链表的以下操作：获取第n个节点；在链表的最前面插入一个节点；在链表的最后面插入一个节点；在链表的第n个节点前面插入一个节点；删除链表的第n个节点；

代码

class MyLinkedList {
public:
    //定义链表
    struct ListNode {
        int val;
        ListNode* next;
        ListNode(int val) : val(val) , next(nullptr) {}
    };
    //初始化链表
    MyLinkedList() {
        dummyhead = new ListNode(0); //虚拟头节点
        size = 0;
    }
    //获取第index个元素
    int get(int index) {
        if(index > (size - 1) || index < 0) {
            return -1;
        }
        ListNode* cur = dummyhead;
        while(index -- ) {
            cur = cur -> next; 
        }
        return cur -> next -> val;
    }
    //在链表的最前面插入一个节点
    void addAtHead(int val) {
        ListNode* cur = dummyhead;
        ListNode* Node = new ListNode(val);
        Node -> next = cur -> next;
        cur -> next = Node;
        size ++;
    }
    //在链表的最后面插入一个节点
    void addAtTail(int val) {
        ListNode* cur = dummyhead;
        ListNode* Node = new ListNode(val);
        while(cur -> next != nullptr) {
            cur = cur -> next; 
        }
        cur -> next = Node;
        Node -> next = nullptr;
        size ++;
    }
    //在链表的第index个节点前面插入一个节点
    void addAtIndex(int index, int val) {
        if(index > size) return; //注意此处 index > size 而非 size-1
        if(index < 0) index = 0;
        ListNode* cur = dummyhead;
        ListNode* Node = new ListNode(val);
        while(index --) {
            cur = cur -> next;
        }
        Node -> next = cur -> next;
        cur -> next = Node;
        size ++;
    }
    //删除链表的第index个节点
    void deleteAtIndex(int index) {
        if(index > size - 1 || index < 0) {
            return;
        }
        ListNode* cur = dummyhead;
        while(index --) {
            cur = cur -> next;
        }
        ListNode* tmp = cur -> next;
        cur -> next = cur -> next -> next;
        delete tmp;
        size --;
    }
    private:
        int size;
        ListNode* dummyhead;
};

小结

• 头节点head代表第0个节点，最后一个节点代表第 size-1 个节点；
• 注意细节，eg：插入时，第n个节点和第 n-1 个节点要区分开，并且结束时将 size++；删除时，指针的先后指向要分辨好；
• cur不能放入私有权限中直接使用，而需在每个函数中都定义初始化一遍，否则会大量报错；

3.翻转链表

题目

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

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]

• -5000 <= Node.val <= 5000

思路

• 双指针方法：定义两个指针 pre，cur，首先 pre 指向空，cur指向头节点，两指针按顺序逐步遍历链表，使链表节点指针方向翻转，从而翻转整个链表；
• 递归法：按照双指针思路，定义翻转函数reverse函数，递归翻转链表；

代码

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //双指针
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* tmp; //临时指针
        while(cur) {
            tmp = cur -> next;
            cur -> next = pre; //翻转
            pre = cur; //更新遍历
            cur = tmp;
        }
        return pre; //新头节点
    }
};

class Solution {
public:
    //递归法
    ListNode* reverse(ListNode* pre, ListNode* cur) {
        if(cur == nullptr) return pre; //结束条件
        ListNode* tmp = cur -> next; //临时指针
        cur -> next = pre; //翻转
        return reverse(cur,tmp); //递归
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(nullptr,head); //初始递归赋值
    }
};

小结

• 注意翻转时指针的指向，递归仍不熟练，思路仍需细捋；

参考

代码随想录 (programmercarl.com)