LeetCode第二章链表|203.移除链表元素，707.设计链表， 206.反转链表

y老番茄y

已于 2022-12-31 22:57:01 修改

阅读量721

点赞数

分类专栏：代码随想录算法训练营文章标签：链表算法数据结构

于 2022-12-30 21:20:51 首次发布

本文链接：https://blog.csdn.net/qq_45662160/article/details/128500833

版权

代码随想录算法训练营专栏收录该内容

5 篇文章 0 订阅

订阅专栏

203_移除链表元素

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

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == 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
输出：[]

解法一：不使用虚拟头结点

不使用虚拟头结点时，有两个情况要考虑。

第一种是待删除的元素为头结点

这里要注意判断头结点是否为空，避免操作空指针。判断好后将头指针后移即为删除该元素。

在这里插入图片描述

第二种是待删除的元素不是头结点

这里我们要设置一个current指针指向头结点，如果判断current指向的下一个节点的值为val时，就将该节点删除。

ListNode* removeElements(ListNode* head, int val) {
    while (head != NULL && head->val == val) {	// 确保头结点不为空，以免操作空指针报错
        ListNode* tmp = head;
        head = head->next;		// 头结点后移
        delete tmp;
    }
    ListNode* current = head;
    while (current != NULL && current->next != NULL) {
        if (current->next->val == val) {
            ListNode* tmp = current->next;
            current->next = current->next->next;
            delete tmp;
        }
        else {
            current = current->next;
        }
    }
    return head;
}

解法二：使用虚拟头结点

使用虚拟头结点时，我们就相当于把解法一的两种情况统一为第二种情况。

在这里插入图片描述

最后要记得重新把head赋值为dummyHead->next，更新为最终的头结点。

ListNode* removeElements(ListNode* head, int val) {
    ListNode* dummyHead = new ListNode(0);    // 虚拟头结点
    dummyHead->next = head;
    ListNode* current = dummyHead;      // 当前指针
    while (current != NULL && current->next != NULL) {
        if (current->next->val == val) {
            ListNode* tmp = current->next;
            current->next = current->next->next;
            delete tmp;
        }
        else {
            current = current->next;
        }
    }
    head = dummyHead->next;		// 更新头结点
    delete dummyHead;
    return head;
}

707_设计链表

题目链接：707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

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

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

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

解答：

本题就是完成链表的基本操作。

class MyLinkedList {
public:
    struct ListNode		// 构建结构体
    {
        int val;
        ListNode* next;
        ListNode(int x) :val(x), next(nullptr) {};

    };

    MyLinkedList() {	// 初始化
        size = 0;
        dummyHead = new ListNode(0);
    }

    int get(int index) {    // 获取链表中第 index 个节点的值。如果索引无效，则返回-1。
        int val;
        ListNode* current;
        if (index >= size || index < 0) {
            return -1;
        }
        current = dummyHead->next;
        while (index--) {
            current = current->next;
        }
        return current->val;
    }

    void addAtHead(int val) {   // 在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
        ListNode* newNode = new ListNode(val);
        newNode->next = dummyHead->next;
        dummyHead->next = newNode;
        size++;
    }

    void addAtTail(int val) {   // 将值为 val 的节点追加到链表的最后一个元素。
        ListNode* newNode = new ListNode(val);
        ListNode* current = dummyHead;
        while (current->next != nullptr) {  // 找到尾节点
            current = current->next;
        }
        current->next = newNode;
        newNode->next = nullptr;
        size++;

    }

    // 在链表中的第 index 个节点之前添加值为 val 的节点。
    // 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
    // 如果 index 大于链表长度，则不会插入节点。
    // 如果index小于0，则在头部插入节点。
    void addAtIndex(int index, int val) {   
        ListNode* newNode = new ListNode(val);
        if (index == size) {
            addAtTail(val);
            return;
        }
        else if (index < 0) {
            addAtHead(val);
            return;
        }
        else if (index > size) {
            return;
        }
        ListNode* current = dummyHead;
        while (index--)
        {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
        size++;
    }

    void deleteAtIndex(int index) { // 如果索引 index 有效，则删除链表中的第 index 个节点。
        if (index >= size || index < 0)
            return;
        ListNode* current = dummyHead;
        while (index--)
        {
            current = current->next;
        }
        ListNode* tmp = current->next;		// 使用C++删除时，要记得链表空间释放
        current->next = current->next->next;
        delete tmp;
        size--;
    }
private:
    int size;
    ListNode* dummyHead;
};

206_反转链表

题目链接：206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

解法一：双指针解法

在这里插入图片描述

设置三个指针，current和pre用来进行反转，tmp用来保存current的下一个结点，便于pre和current指针后移。

这里注意反转后，原来的头指针应该指向NULL，因此最初的pre指针初始化应为pre = NULL。

ListNode* reverseList(ListNode* head) {
    ListNode* pre = NULL;		// 初始化pre为空
    ListNode* current = head;   // current指向头结点
    ListNode* tmp;				// 用于存放current的下一个结点
    while (current)
    {
        tmp = current->next;
        current->next = pre;	// 反转
        pre = current;			// pre后移
        current = tmp;			// current后移
    }
    return pre;
}

解法二：递归

递归方法就是将双指针方法简化了一下。将while循环改为用递归函数来实现，代码更简洁。

ListNode* reverse(ListNode* pre, ListNode* current) {	// 递归函数
    if (current == NULL)
        return pre;
    ListNode* tmp = current->next;	// 存放current的下一个结点
    current->next = pre;			// 指针反转
    return reverse(current, tmp);	// 相当于pre = current; current = tmp;
}

ListNode* reverseList(ListNode* head) {
    return reverse(NULL, head);
}