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

链表基础知识

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

题目一

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

题目链接

自己的解法

思考

链表中的元素是不可以直接删掉的，得先让上一个元素的指针指向下一个元素，然后再delete该元素。

class Solution
{
public:
    ListNode *removeElements(ListNode *head, int val)
    {
        while (head->val ！= NULL)
        {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } 
        }
    }
};

报错：

self.cpp: In member function 'ListNode* Solution::removeElements(ListNode*, int)':
self.cpp:28:5: warning: no return statement in function returning non-void [-Wreturn-type]
     }
     ^

应该是有空链表情况，今天时间较紧，直接看随想录怎么写的吧

二分法解法

好吧，我甚至都没完整的考虑一种情况。。。

如果不设置虚拟头结点：

class Solution
{
public:
    ListNode *removeElements(ListNode *head, int val)
    {
        while (head->val == val && head != NULL)
        {
            ListNode *tmp = head;
            head = head->next;
            delete tmp;
        }

        ListNode *cur = head;
        while (cur->next != NULL && cur != NULL)
        {
            if (cur->next->val == val)
            {
                ListNode *tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else
                cur = cur->next;
        }
        return head;
    }
};

如果设置虚拟头结点：

虚拟头结点是一个好的东西，直接让要思考的情况少了一种，也即不要思考头结点情况。

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

只要记住删掉dummyhead就可以了

题目二

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

题目链接

思考

这道题就是直接将链表中用的到的操作都考了一遍，以下是解法：

解法

先是定义一个链表

仿造上一个的写法：

   struct ListNode
    {
        int val;
        ListNode *next;
        ListNode(int val) : val(val), next(nullptr) {}
    };

构造函数主要是dummyhead的定义以及size初始化¹

    MyLinkedList()
    {
        _dummyhead = new ListNode(0);
        _size = 0;
    }

getindex函数

    int get(int index)
    {
        ListNode *cur = _dummyhead->next;
        if (index > _size - 1)
            return -1;
        while (index--)
        {
            cur = cur->next;
        }
        return cur->val;
    }

addAtHead函数

    void addAtHead(int val)
    {
        ListNode *cur = new ListNode(val);
        cur->next = _dummyhead->next;
        _dummyhead->next = cur;
        _size++;
    }

addAtTail函数

这个就有意思了，主要问题是怎么定义到尾部
这里实在是想不到什么好的办法，故看了一下随想录的答案：居然是一步步遍历到尾部的

void addAtTail(int val)
    {
        ListNode *newNode = new ListNode(val);
        ListNode *cur = _dummyhead->next;
        while (cur->next != NULL)
        {
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

addAtIndex函数¹

这个其实就是addAtTail和getIndex的结合

    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        ListNode* newNode = new ListNode(val);
        ListNode* cur = _dummyhead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

deleteAtIndex函数¹

    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        ListNode* cur = _dummyhead;
        while(index--) {
            cur = cur ->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp=nullptr;
        _size--;
    }

当然，这个是提交不了的版本，leetCode的该题所有的链表定义都为LinkedNode

题目三

题意：反转一个单链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
题目链接

思考

感觉最简单的方法就是再创建一个链表，然后再把这个倒序填进去
貌似还是很难，今天时间紧，就先看一种解法吧。

双指针法

手动抄了一遍，挺简单的，怎么就自己没想到。。。

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

递归法

先写到这，周末补上递归法

---

1. 这里是偷看答案的 ↩︎ ↩︎ ↩︎