203.移除链表元素、707.设计链表、206翻转链表

203.移除链表元素、707.设计链表、206翻转链表

203.移除链表元素

题目链接

题意：删除链表中等于给定值 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 输出：[]

//需要清楚链表结构体的定义
struct ListNode{
    int val;
    ListNode *next;
    ListNode():val(0),next(nullptr){}
    ListNode(int val):val(val),next(nullptr){}
    ListNode(int val,ListNode *next):val(val),next(next){}
};

考察对链表的操作，需要记得手动删除内存。

重点：需要考虑到，删除链表头指针操作与删除后面的指针操作有区别。

思路：虚拟头指针 手动设置一个虚拟头指针，统一链表的操作。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
            ListNode *fakeHead = new ListNode(0,head);//虚拟头指针
            ListNode *node=fakeHead;
            ListNode *deleteNode;
            while(node->next!=NULL)
            {
                if(node->next->val==val)
                {
                    deleteNode = node->next; //记录要删除释放内存的节点
                    node->next = node->next->next;
                    delete (deleteNode); //释放指针所指的内存区
                }
                else
                {
                    node = node->next; 
                }
            }
            head=fakeHead->next;//找到原来的头节点
            delete(fakeHead); //释放指针所指的内存区
            return head;
    }
};

707.设计链接

题目链接

文章链接

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

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：设置虚拟头指针！！

class MyLinkedList {
public:

    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode *next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    MyLinkedList() {
        _fakeHead = new LinkedNode(0);
        _size = 0;//链表元素个数
    }
    
    int get(int index) {
        if(index+1>_size || index <0)
            return -1;
        
        LinkedNode *cur = _fakeHead->next; 
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode *newNode= new LinkedNode(val);
        newNode->next = _fakeHead->next;
        _fakeHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode *cur = _fakeHead;
        while(cur->next!=nullptr)
            cur=cur->next;
        LinkedNode *newNode= new LinkedNode(val);
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>_size)
            return;
        if(index<0)
            index=0;
        LinkedNode *cur = _fakeHead; 
        while(index--)
            cur = cur->next;
        LinkedNode *newNode = new LinkedNode(val);
        newNode->next=cur->next;
        cur->next=newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index+1>_size)
            return;
        LinkedNode *cur = _fakeHead;
        while(index--)
            cur=cur->next;
        LinkedNode *tmp = cur->next;
        cur->next = tmp->next;
        delete(tmp);
        tmp=nullptr;
        _size--;
    }
private:
    int _size;
    LinkedNode* _fakeHead;

};

206.反转链表

题目链接

文章链接

思路一：双指针

//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre = NULL;//前一个节点
        ListNode *cur = head;//当前节点

        while(cur)
        {
            ListNode *temp=cur->next;//存放下一节点
            cur->next = pre;//翻转当前节点

            pre = cur//移动指针;
            cur = temp;//移动指针
        }

        return pre;
    }
};

思路二：递归

递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可能有的同学会不理解， 可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。

//时间复杂度：O(n)  递归遍历了每一个元素
//空间复杂度：O(n)  调用了n层栈空间

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
      return reverse(head,NULL);
    }

    ListNode*reverse(ListNode *cur,ListNode *pre)
    {
        if(cur==NULL)
            return pre;
        ListNode *tmp = cur->next;
        cur->next = pre;
        
        //pre = cur; 
        //cur = temp;
        return reverse(tmp,cur); //对比上面双指针的指针位移
    }
};