代码随想录【day 3】| 203.移除链表元素、206.反转链表 、 707.设计链表

203.移除链表元素

题目链接：203.移除链表元素

卡尔文字讲解

卡尔视频讲解

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

示例：

解题思路重点：

1. 使用 Dummy head，在被删除节点是头节点的情况下，可以统一删除方式。（ current->next = current->next->next ）
2. 总是要让 current 指针，指向被删除节点的前一个结点。
3. 判断空指针 current->next

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        ListNode *dummy_head = new ListNode( -999, head );
        ListNode *current = dummy_head;

        while( current->next ){

            if( current->next->val == val )
                current->next = current->next->next;
            else 
                current = current->next;
        }
    
        return dummy_head->next;
    }
};

206. 反转链表

题目链接：206.反转链表

卡尔文解

视频讲解

题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

解题思路及注意事项：

1. 定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。
2. 要把 cur->next 节点用 tmp 指针暂时保存一下。
3. 为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ， 此时已经反转了第一个节点了。
4. 接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。
5. 最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *prev = NULL;
        ListNode *currt = head;

        
        while( currt ){
            ListNode *tmp = currt->next; // Save next pointer, otherwise original link list will be lost.
            currt->next = prev;
            prev = currt;
            currt = tmp;
        }

        return prev;
    }
};

707. 设计链表

题目链接

卡尔文解

解题思路重点：

1. addAtIndex 在某个 Index 前增加节点 操作的时候：使用 Dummy head，可以把在头节点跟普通节点之前的插入操作，归并为一段代码。避免在头节点前插入需要额外判断与操作。

    while( index-- ) { current = current->next; } // 调整指针 inorder to 指向 Index 之前一个结点。
    insert_node->next = current->next; // 在 Index 之前插入新节点
    current->next = insert_node
   

代码实现：

class MyLinkedList {

private: 
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    
    LinkedNode *_dummy_head;
    int _size;
    
public:
    MyLinkedList() {
             _dummy_head = new LinkedNode( -9999 ); 
             _size = 0;
    }
    
    int get(int index) {

        LinkedNode *current = _dummy_head->next;

        if( index < 0 || index > _size - 1) 
            return -1;

        while( index-- ){
            current = current->next;
        }
        return current->val;
    }
    
    void addAtHead(int val) {

        LinkedNode *insert_node = new LinkedNode( val );
        insert_node->next = _dummy_head->next;
        _dummy_head->next = insert_node;
        _size++;
    }
    
    void addAtTail(int val) {

        LinkedNode *append_node = new LinkedNode( val );
        LinkedNode *current = _dummy_head;

        while( current->next ){
            current = current->next;
        }

        current->next = append_node;
        _size++;
    }
    
    void addAtIndex(int index, int val) {

        if( index > _size ) return;
        if( index < 0 ) index = 0;
        
        LinkedNode *current = _dummy_head;
        LinkedNode *insert_node = new LinkedNode( val );

        while( index-- ){
            current = current->next;
        }

        insert_node->next = current->next;
        current->next = insert_node;
        _size++;
    }
    
   void deleteAtIndex(int index) {
        
        if(( index >= _size ) || index < 0 ) {
            return;
        }
        
        LinkedNode *current = _dummy_head;
        
        while( index-- ){
            current = current->next;
        }
        
        current->next = current->next->next;
        _size--;
    }
    
};

总结

对于链表的 增 删 改 查 4个操作，其中 增 删 操作（即改变链表本身结构操作）强烈建议使用一个 Dummy head的策略 ，从而使代码简化！