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

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

单链表、双链表、循环链表

 

 链表在内存中不是连续分布的，链表是通过指针域的指针链接在内存中各个节点。

 C/C++的定义链表节点方式：

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

不定义构造函数，C++默认生成一个构造函数，但是在初始化的时候就不能直接给变量赋值！例如：

ListNode* head = new ListNode(5);

203.移除链表元素

思路：基本的单链表遍历及删除操作。

时间复杂度：O(n)

空间复杂度：O(1)

 分析：

使用头结点，可以统一链表的插入和删除操作。

注意：

单链表的定义，以及使用构造函数的写法。

代码实现：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* newhead = new ListNode(0, head);
        ListNode* p = newhead;
        ListNode* q = newhead->next;
        while(q != NULL){
            if(q->val == val){
                p->next = q->next;
                q = q->next;
            }
            else{
                p = p->next;
                q = q->next;
            }
        }
        return newhead->next;
    }
};

707.设计链表

思路：单链表各种操作：定义、初始化、查找、插入、删除、遍历。

时间复杂度：略

空间复杂度：略

分析:

掌握好基本的遍历、插入、删除即可。

注意：

1.单链表的定义，以及使用构造函数的写法。

    //定义链表结点
    struct ListNode{
        int val;
        ListNode *next;
        //构造函数
        ListNode(int x) : val(x), next(NULL) {}
    };

    //使用构造函数new一个节点，这个节点data域为0，next域为NULL
    tmp = new ListNode(0);

2.初始化链表时，所用到的变量要在private中自己定义。初始化一个链表，需要一个头结点、一个链表长度。

3.链表长度size大小一定要随着插入删除操作及时更改，不要忘记。

class MyLinkedList {
public:
    //定义链表结点
    struct ListNode{
        int val;
        ListNode *next;
        //构造函数
        ListNode(int x) : val(x), next(NULL) {}
    };
    MyLinkedList() {
        //初始化一个空的单链表，它有一个头结点，size记录它的长度
        dummyHead = new ListNode(0);
        size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        else{
            ListNode *p = dummyHead->next;
            for(int i = 0; i < index; i++){//移动index次
                p = p->next;
            }
            return p->val;
        }
    }
    
    void addAtHead(int val) {
        ListNode *tmp = new ListNode(val);
        ListNode *p = dummyHead->next;
        tmp->next = p;
        dummyHead->next = tmp;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode* p = dummyHead;
        while(p->next != NULL){
            p = p->next;
        }
        ListNode* tmp = new ListNode(val);
        p->next = tmp;
        tmp->next = NULL;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index >=0 && index < size){
            //插到前面
            ListNode *p = dummyHead;
            for(int i = 0; i < index; i++){//移动index次
                p = p->next;
            }
            ListNode* tmp = new ListNode(val);
            tmp->next = p->next;
            p->next = tmp;
            size++;

        }
        else if(index == size){
            //插到尾部
            ListNode* p = dummyHead;
            while(p->next != NULL){
                p = p->next;
            }
            ListNode* tmp = new ListNode(val);
            p->next = tmp;
            tmp->next = NULL;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index >= 0 && index < size){
            ListNode* p = dummyHead;
            //将p指向index-1的位置
            for(int i = 0; i < index; i++){//移动index次
                p = p->next;
            }
            ListNode* q = p->next;//q是待删除节点、
            p->next = q->next;
            delete(q);
            size--;
        }
    }
private:
ListNode* dummyHead;
int size;
};

206.反转链表

思路：想通过创建一个虚拟头结点和反向复制节点来反转链表，但这个方法复杂且容易出错。

时间复杂度：略

空间复杂度：略

 代码实现（未通过）：

/**
 * 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* dummyHead = new ListNode(0,head); //创建虚拟头结点
        ListNode* p = dummyHead;
        while(p->next != NULL){//p指向链表最末尾
            p = p->next;
        }
        ListNode* q = dummyHead->next;
        dummyHead = p->next;

        while(q != dummyHead){
            ListNode* tmp = new ListNode(0,NULL);
            tmp->val = q->val;
            p->next = tmp;
            p = p->next;
            ListNode* tmpDelete = q;
            q = q->next;
            delete(tmpDelete);
        }

        return dummyHead->next;

    }
};

思路：双指针。直接反转链表中的指针。

时间复杂度：O(n)

空间复杂度：O(1)

注意：

1.两个指针的初始情况，循环退出的条件 。

2.指针反转之后链表会断掉，因此需要tmp指针在反转之前暂存一下，把链表接上。

代码实现：

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

思路：递归。将一个复杂的大问题转化为多个简单一样的小问题，依据双指针的思路来写。

时间复杂度：O(n)

空间复杂度：O(n)

 注意：

1.要先掌握双指针，依据双指针的思路来写递归的代码，否组不够直观。

2.递归要注意两点：1）跳出递归的条件；2）循环的基本操作。

代码实现：

class Solution {
public:
    
    ListNode* reverse(ListNode* rear, ListNode* front){
        if(front == NULL){
            return rear;
        }
        else{
        ListNode* tmp = front->next;
        front->next = rear;
        return reverse(front, tmp);
        }
    }
    
    ListNode* reverseList(ListNode* head) {
        return reverse(NULL, head);
    }
};