《算法系列》之链表

已于 2022-07-23 17:50:34 修改
阅读量408 收藏
点赞数 2
分类专栏： 算法 文章标签： 链表 算法 数据结构 leetcode
于 2022-06-30 20:23:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22136439/article/details/122231911
版权

简介

   我们平时会发现如果一道题如果涉及数据结构，那么他的算法思路一般相对其它同等难度的题要简单，其实链表也一样，纯链表的题也不会特别难。了解了一些套路之后，做题方法也是有迹可寻，我们可以适当记一些模板，这样可以加快我们解题的速度，比如如何寻找中点，用虚拟节点或递归法反转链表等，其中递归是链表篇的重点，其实也整个刷题生涯中的重点，链表中的递归，回溯中的递归，二叉树和图中的递归等等，所以这里也会讲一下递归的书写模板，要重点学习。

理论基础

  链表是一种线性存储结构，采用的是链式存储。可以采用连续的存储空间，也可以采用零散的非连续存储空间。 数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表示意图如下：
请添加图片描述
   除了以上这种单链表以外，还有双向链表和循环链表。在单链表的基础上，对于每一个结点设计一个前驱结点，前驱结点指向前一个结点，构成一个链表，就产生了双向链表的概念了。即每个节点都有两个指针。双向链表示意图如下：

请添加图片描述
循环链表其实也好理解，就是首尾节点连接在一起了罢了，我们平时写链表代码时，如非必要，要注意循环链表的产生，否则可能会导致CPU空转，出现致命BUG，循环链表示意图如下：
请添加图片描述

链表的特点
  • 是一种线性存储结构。
  • 节点值包含两部分，分别为数据域和指针域。
  • 可以采用零散的存储空间。
  • 和数组相比，内存消耗更大，主要需要多存一个指针域。
  • 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
  • 和数组比，无固定长度，理论上来讲，只要内存没爆，能一直存。
  • 线性链表还可分为单链表，双向链表，循环链表等。
  • 链表节点的增加一般有头插入法和尾插入法两种。

链表类的定义：

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
解题方式

   解链表的题，一定要会两招，一招是递归，一招是迭代法。其中递归的写法可以分成三步走：

  • 一、明确函数功能： 要清楚你写这个函数是想要做什么。

  • 二、寻找递归出口： 递归一定要有结束条件，不然会永远递归下去，禁止套娃。

  • 三、找出递推关系： 开始实现递归，一步一步递推出最终结果。
    递归方式主要在链表反转时，或者需要从后往前操作链表时，经常用到，写递归函数时，一定要明确递推关系和递归出口，否则不可能写好递归的。至于迭代法，其实不过就是写循环，一般比递归要好理解一些，代码也更好写，但有的题不能直接看出来用迭代法，但请相信：所有的递归都可以用循环来写。接下来看一下递归和迭代的模板：

    // 递归模板
class Solution {
    public BBB AAA(ListNode head) {
        return helper(入参);
    }

    private BBB helper(入参) {
        if (终止条件) {
            return xxx;
        }
        // 函数功能
        return helper(参数); # 递归调用
    }
}

// 迭代模板
... 其实就是 for 或 while 循环 ...
	for(...){
		... ...
	}

	while(...){
		... ...
	}

    下面以反转链表这题经典题，来展示这两种方法。

    // 递归法反转链表
class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
}

// 迭代法反转链表
class Solution {
    public ListNode reverseList(ListNode head) {
        // 申请新虚拟节点
        ListNode dummy = new ListNode(0);
        ListNode p = dummy, cur = head;
        while(cur != null){
            // 从head摘下一个头
            ListNode t = cur;
            cur = cur.next;     // cur移到下一个
            t.next = p.next;    // 头插法插入，依次反转
            p.next = t;
        }
        return dummy.next;
    }
}

   以上迭代法的书写方式，也可以叫做虚拟头节点法，相当于递归来说，更易于我们理解。链表的题，有时申请一个虚拟头节点，题解就会豁然开朗。

解题心得

  • 只要弄清链表的特性，单纯的链表题一般也不难。
  • 一定要学会几种反转链表的方式，很重要。
  • 递归一定要好好学习，无论是链表题，还是之后的题，都会经常用到，最好能理解并默写模板。
  • 寻找链表中点，只需要用双指针，Slow前行一步，Fast前行两步，Fast到底，Slow就是中间节点了。
  • 在leetcode中通常链表已经定义好了，但我们平时也要注意链表类的定义怎么写，因为面试时，是不会有人给你定义的，这些都需要你自己写。

算法题目

2. 两数相加

在这里插入图片描述
题目解析：将两链表直接相加，要注意进位（carry）的处理，这里可以用虚拟头节点来处理链表，会更方便。
代码如下：

/**
 * Definition for singly-linked list.
 * public caass ListNode {
 *     int bal;
 *     ListNodeint val; next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 
/**
 * 链表
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 声明一个虚拟头节点
        ListNode dummyHead = new ListNode(0);
        ListNode curr = dummyHead;
        int carry = 0;
        // 只要有一个链表不为空，则需继续相加
        while(l1 != null || l2 != null){
            int a = (l1 != null) ? l1.val : 0;
            int b = (l2 != null) ? l2.val : 0;
            int sum = carry + a + b;
            // 无进位，则carry为零
            carry = sum / 10;
            // 节点值为个位数数值
            curr.next = new ListNode(sum % 10);
            curr = curr.next;
            if(l1 != null ) l1 = l1.next;
            if(l2 != null ) l2 = l2.next;
        }
        // 若最后有进位，则新加一个节点
        if(carry > 0){
            curr.next = new ListNode(carry);
        }
        return dummyHead.next;
    }
}
24. 两两交换链表中的节点

在这里插入图片描述
题目解析：递归整个链表，然后按两两相交的规则，重新生成新链表。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 
 /* 
  * 递归
  */
class Solution {
    public ListNode swapPairs(ListNode head) {
        return swap(head);
    }

    public ListNode swap(ListNode head){
        
        if(head == null || head.next == null){
            return head;
        }
        
        ListNode tampA = head;
        ListNode tampB = head.next.next;
        // 按新链表的生成顺序，完成代码书写，更便于理解
        head = head.next;
        head.next = tampA;
        head.next.next = swap(tampB);
        return head;
    }
}
25. K 个一组翻转链表

在这里插入图片描述
题目解析：这里需要双重递归，每过K个节点，再执行递归进行链表反转这K个节点。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

/**
 * 双层递归
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        // 新的head
        ListNode newHead = head;
        // 运行至该节点
        ListNode tempA = head;
        for (int i = 0; i < k; i++) {
            if (tempA == null) {
                return head;
            }
            if (i == k - 1) {
                newHead = tempA;
            }
            tempA = tempA.next;
        }
        // 反转后的最后一个节点
        ListNode tempB = reverse(head, k);
        // 当前段最后一个节点与下一段开头相连
        tempB.next = reverseKGroup(tempA, k);
        return newHead;
    }

    /**
     * 用递归反转链表
     */
    public ListNode reverse(ListNode head, int k) {
        if (k == 1) {
            return head;
        }
        ListNode newHead = reverse(head.next, --k);
        newHead.next = head;
        return newHead.next;
    }
}
83. 删除排序链表中的重复元素

在这里插入图片描述
题目解析：直接遍历全链表，有重复删除即可。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

/**
 * 链表
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode res = head;
        while (head != null && head.next != null) {
            if (head.val == head.next.val) {
                head.next = head.next.next;
            } else {
                head = head.next;
            }
        }
        return res;
    }
}
92. 反转链表 II

在这里插入图片描述
题目解析：用递归反转指定范围里的节点，再连接进主链表即可。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

/**
 * 递归
 */
class Solution {

    ListNode successor = null;

    public ListNode reverseBetween(ListNode head, int left, int right) {

        if (left == 1) {
            return helper(head, right);
        }

        head.next = reverseBetween(head.next, left - 1, right - 1);
        return head;
    }

    public ListNode helper(ListNode head, int n) {
        if (n == 1) {
            successor = head.next;
            return head;
        }

        ListNode last = helper(head.next, n - 1);
        head.next.next = head;
        head.next = successor;
        return last;
    }
}
155. 最小栈

在这里插入图片描述

题目解析：用链表，每个节点存储时，把该节点情况下最小值也存进去即可。
代码如下：

/**
 * 链表
 */
class MinStack {
    private Node head;
    
    public void push(int x) {
        if(head == null) 
            head = new Node(x, x);
        else 
            head = new Node(x, Math.min(x, head.min), head);
    }

    public void pop() {
        head = head.next;
    }

    public int top() {
        return head.val;
    }

    public int getMin() {
        return head.min;
    }
    
    private class Node {
        int val;
        int min;
        Node next;
        
        private Node(int val, int min) {
            this(val, min, null);
        }
        
        private Node(int val, int min, Node next) {
            this.val = val;
            this.min = min;
            this.next = next;
        }
    }
}
/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */
203. 移除链表元素

在这里插入图片描述
题目解析：虚拟头节点，用虚拟头节点的好处是，防止第一个节点也是删除的节点的情况，且方便返回头节点。

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 
/**
 * 链表
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode header = new ListNode(-1);
        header.next = head;
        ListNode cur = header;
        while(cur.next != null){
            // 当前节点下一节点为删除节点时，直接删除掉下一节点
            if(cur.next.val == val ){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return header.next;
    }
}
206. 反转链表

在这里插入图片描述
题目解析：虚拟头节点，用虚拟头节点方便返回头节点。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 
 /**
  * 链表
  */
class Solution {
    public ListNode reverseList(ListNode head) {
        
        if(head == null){
            return null;
        }

        ListNode dummyHead = new ListNode(-1);
        while(head != null){
            ListNode temp = dummyHead.next;
            dummyHead.next = new ListNode(head.val);
            dummyHead.next.next = temp;
            head = head.next;
        }
        return dummyHead.next;
    }
}
237. 删除链表中的节点

在这里插入图片描述
题目解析：依次用后一节点的值代替当前节点的值。
代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

/**
 * 链表
 */
class Solution {
    public void deleteNode(ListNode node) {
        // 今当前节点值为下一节点值
        node.val = node.next.val;
        // 申请下一节点
        ListNode nextNode = node.next;
        // 判断依次替换之后的节点
        while (nextNode.next != null) {
            nextNode.val = nextNode.next.val;
            node = nextNode;
            nextNode = nextNode.next;
        }
        // 删除最后一个节点
        node.next = null;
    }
}
回到首页

刷 leetcode 500+ 题的一些感受

下一篇

《算法系列》之哈希表

小夏陌
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法-链表
jianyong的博客
05-09 404
算法、链表、leetcode、实例化节点、ListNode类、求两个 升序链表 的并集、两数相加、删除链表的倒数第 N 个结点、旋转链表、反转链表、反转链表II、链表中的下一个更大节点、单调栈
头插法逆序输出单链表
许你一片梁城的博客
09-11 1189
带头结点单链表逆序输出 算法思想：遍历链表元素，利用头插法建立新的链表，这样新生成的链表就是之前的逆序链表，直接对其进行输出即可。（函数中没有写头结点初始化的信息，读者自行补充） 1.链表节点结构 typedef struct LNode{ int data; struct LNode* next; }LNode,*LinkList; 2.链表逆序 //链表逆序 void RevLinkList(LinkList &L){ LNode *p = L->ne
1.算法之链表
CarmenIsOK的博客
03-19 147
&lt;LeetCode&gt; 链表逆序 反转链表 反转一个单链表。 示例: 输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL 输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL class Solution { public: ListNode* reverseList(ListNode* head) {
C++冒泡算法排序和链表中的应用
最新发布
05-07
链表是一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在链表中，元素的位置不连续，这与数组不同。冒泡排序在链表上的实现相比数组会更复杂，因为我们需要遍历链表节点，而不是...
JavaScript数据结构与算法之链表
10-22
`LinkedList`构造函数还需要实现一系列操作链表的方法，例如： 1. `append(element)`：在链表末尾添加新节点。如果链表为空，新节点直接成为头节点；否则，遍历链表找到最后一个节点，将其`next`指向新节点。 2. `...
Java算法篇-链表去重与合并.pptx.pptx
12-18
链表不同于数组，它的元素不是连续存储的，而是由一系列节点构成，每个节点包含数据以及指向下一个节点的引用（或称为指针）。在Java中，链表可以使用`Node`类来表示，每个`Node`包含一个数据字段和一个指向下一个`...
python算法题 链表反转详解
09-19
### Python算法题：链表反转详解 在计算机科学与编程领域中，链表是一种常见的数据结构，被广泛应用于各种场景之中。链表反转是链表操作中最基础且重要的操作之一，它不仅能够帮助理解链表的基本操作原理，还能够在...
链表逆置+算法+详解介绍
09-17
链表是一种非连续存储的数据结构，由一系列节点组成，每个节点包含一个值和一个指向下一个节点的指针。根据指针方向和结构，链表可以分为单向链表、双向链表和循环链表等类型。在链表逆置问题中，我们通常讨论的是...
算法之链表
yaoyao071500的博客
03-11 1961
`链表简单算法题 1.将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成。（附leetcode 21.) //方法一 struct ListNode *mergeTwoLists(struct ListNode* l1, struct ListNode* l2){ if(!l1) return l2; if(!l2) return l1; struct ListNode *head=(struct ListNode*
数据结构和算法之链表
可小辉的博客
01-22 164
1.链表(LinkedList) 1.1链表(LinkedList)介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data域， next域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下 2.单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完...
算法——链表
一个憨憨写的胡言乱语
09-16 305
算法
算法：链表
Elson的博客
03-02 441
链表（Linked List）是最简单的线性的、动态数据结构。理解它是理解树结构、图结构的基础。链表在插入数据的时候可以达到 O(1) 的复杂度，但是查找一个节点或者访问特定编号的节点则需要 O(n) 的时间。
算法 - 链表
Ralap的博客
02-18 369
链表单链表反转双向链表反转单链表删除某一个值的节点单链表，链表长度为基数则返回中点元素，偶数则返回上中点元素单链表，链表长度为基数则返回中点元素，偶数则返回下中点元素单链表，链表是否是回文结构 单链表反转 将链表的头结点变成尾结点 /** * 翻转单链表 * * @param head * @return */ public static Node reverseLinkedList(Node head) { // 预存前节点
C#数据结构与算法：双向链表和循环链表解析
"链表设计的改进方案-vpython入门-C#数据结构与算法" 在软件开发中，数据结构和算法的学习至关重要，尤其是对于专业程序员来说。本文档主要关注链表设计的改进，包括双向链表和循环链表的概念，以及如何在C#语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小夏陌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值