训练营day03 链表 | 理论基础、203-移除链表元素、707-设计链表、206-反转链表

理论基础

单链表：

head指向的是头节点，head->val是头节点的数据data，head->next是节点2的地址，即指向节点2，所以head->next->val是节点2的数据，head->next->next是节点3的地址，如果删除节点2就是把节点3的地址给节点1，即head->next = head->next->next，如果删除节点1就是让head指向节点2，即把节点2的地址给head，即head = head->next

数组与链表比较：数组擅长查找，不擅长添加和删除元素；链表擅长添加和删除元素，不擅长查找 

 手写链表：

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

203-移除链表元素

主要原理可以看上面基础部分加粗字体，做法可分为普通做法（分成是否头节点两种情况）和添加虚拟头节点两种做法

C++语言要记得手动清理内存

方法1：头节点的数据是否为目标值

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 是头节点的情况
        // 循环是防止开头几个元素都是目标值
        while(head != NULL && head->val == val){  //NULL表示空指针
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }

        //不是头节点的情况
        //注意这里cur是目标值的前一个元素，为了删除它，单向链表不能往前找
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp; 
            }
            else
                cur = cur->next;
        }
        return head;
    }
};

方法2：添加虚拟头节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 新建一个虚拟头节点
        ListNode* virtualHead = new ListNode(0);
        virtualHead->next = head;

        ListNode* cur = virtualHead;
        while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp; 
            }
            else
                cur = cur->next;
        }
        //真正的第一个节点可能已经发生了变化，所以要重新把地址赋给head
        head = virtualHead->next;
        delete virtualHead;
        return head;
    }
};

707-设计链表

class MyLinkedList {
public:
    // 定义链表节点的结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int x):val(x), next(NULL){}
    };

    // 初始化列表 注意：需要将数据成员私有化，外部不得访问
    MyLinkedList() {
        // 定义虚拟头节点
        _virtualHead = new LinkedNode(0); // 类的成员变量前一般加下划线
        _size = 0; // 节点个数
    }
    
    // 获取指定位置的节点 注意：index是从0到_size-1
    int get(int index) {
        if(index < 0 || index > _size-1)
            return -1;
        LinkedNode* cur = _virtualHead -> next;
        while(index--)
            cur = cur->next;
        return cur->val;
    }
    
    // 在前面添加新节点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _virtualHead->next; //最开始整个链表为空时，就是把NULL给newNode-next
        _virtualHead->next = newNode; // 再让virtualHead指向newNode
        _size++;
    }
    
    // 在后面添加新节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _virtualHead;
        while(cur->next != NULL)
            cur = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size)
            return;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _virtualHead; // 注意是index节点之前
        while(index--)
            cur = cur->next;
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
        
    }
    
    void deleteAtIndex(int index) {
        if(index < _size && index >= 0){
            LinkedNode* cur = _virtualHead;
            while(index--){
                cur = cur->next;
            }
            LinkedNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
            _size--;
        }
    }

// 变量私有化，类外不得访问
private:
    int _size;
    LinkedNode* _virtualHead;
};

206-反转链表

双指针法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp;
        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur != NULL){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;

    }
};

递归法

递归法的逻辑思路和双指针一样，所以可以先写出双指针方法再写递归方法

这次没有手动写递归法，只是看懂了，第二遍可以自己写写

视频：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

今日总结

链表设计还是有点不熟，再多练几遍，还有一种Print操作也可以自己写写