链表基础与题目分析

最新推荐文章于 2024-04-25 23:06:44 发布
最新推荐文章于 2024-04-25 23:06:44 发布
阅读量515 收藏
点赞数
分类专栏： 算法 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40043345/article/details/121856482
版权

链表

目录


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

链表的分类

单链表

最基础的单链表如图所示：

​ 链表1

双链表

单链表中的节点只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表 既可以向前查询也可以向后查询。

如图所示： 链表2

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

链表4

链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

如图所示：

链表3

这个链表起始节点为2， 终止节点为7， 各个节点分布在内存个不同地址空间上，通过指针串联在一起。

链表的定义

这里我给出java的定义链表节点方式，如下所示：

class ListNode {        //类名 ：Java类就是一种自定义的数据结构
    int val;            //数据 ：节点数据 
    ListNode next;      //对象 ：引用下一个节点对象。在Java中没有指针的概念，Java中的引用和C语言的指针类似
    
    ListNode(int val){  //构造方法 ：构造方法和类名相同   
        this.val=val;     //把接收的参数赋值给当前类的val变量
    }
}

有同学说了，我不定义构造函数行不行，答案是可以的，java默认生成一个构造函数。

下面通过一个测试类给出链表的基本操作：

class Test{
    public static void main(String[] args){
        
        ListNode nodeSta = new ListNode(0);          //创建首节点
        ListNode nextNode;                           //声明一个变量用来在移动过程中指向当前节点
        nextNode=nodeSta;                            //指向首节点
        
        //创建链表
        for(int i=1;i<10;i++){
            ListNode node = new ListNode(i);         //生成新的节点
            nextNode.next=node;                      //把心节点连起来
            nextNode=nextNode.next;                  //当前节点往后移动
        } //当for循环完成之后 nextNode指向最后一个节点，
        
        nextNode=nodeSta;                            //重新赋值让它指向首节点
        print(nextNode);                             //打印输出
     
        //插入节点
        while(nextNode!=null){
            if(nextNode.val==5){
                ListNode newnode = new ListNode(99);  //生成新的节点
                ListNode node=nextNode.next;          //先保存下一个节点
                nextNode.next=newnode;                //插入新节点
                newnode.next=node;                    //新节点的下一个节点指向 之前保存的节点
            }
            nextNode=nextNode.next;
        }//循环完成之后 nextNode指向最后一个节点
         nextNode=nodeSta;                            //重新赋值让它指向首节点
         print(nextNode);                             //打印输出
        
        
        //替换节点
        while(nextNode!=null){
            if(nextNode.val==4){
                ListNode newnode = new ListNode(99);  //生成新的节点
                ListNode node=nextNode.next.next;     //先保存要替换节点的下一个节点
                nextNode.next.next=null;              //被替换节点 指向为空 ，等待java垃圾回收
                nextNode.next=newnode;                //插入新节点
                newnode.next=node;                    //新节点的下一个节点指向 之前保存的节点
            }
            nextNode=nextNode.next;
        }//循环完成之后 nextNode指向最后一个节点
         nextNode=nodeSta;                            //重新赋值让它指向首节点
         print(nextNode);                             //打印输出
      
        
        //删除节点
        while(nextNode!=null){
            if(nextNode.val==5){
                ListNode listNode=nextNode.next.next;     //保存要删除节点的下一个节点
                nextNode.next.next=null;                  //被删除节点 指向为空 ，等待java垃圾回收
                nextNode.next=listNode;                   //指向要删除节点的下一个节点
            }
            nextNode=nextNode.next;
        }//循环完成之后 nextNode指向最后一个节点
         nextNode=nodeSta;                            //重新赋值让它指向首节点
         print(nextNode);                             //打印输出
    }
    
    static void print(ListNode listNoed){
        //创建链表节点
        while(listNoed!=null){
            System.out.println("节点:"+listNoed.val);
            listNoed=listNoed.next;
        }
        System.out.println();
    }
}

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

链表的操作

删除节点

删除D节点，如图所示：

链表-删除节点

只要将C节点的next指针 指向E节点就可以了。

那有同学说了，D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。

是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

添加节点

如图所示：

链表-添加节点

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

链表-链表与数据性能对比

移除链表元素

力扣题目链接

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

思路

我一般会加一个虚拟的头节点，这样所有的节点都可以进行一样的增删操作，需要注意的是最后返回的是虚拟头节点的next;

/**
 * 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; }
 * }
 */

/**
 * 添加虚节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }

        ListNode dummy = new ListNode(-1,head);

        ListNode pre = dummy;
        ListNode cur = head;

        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next ;
            }else{
                pre = pre.next;
            }
            cur = cur.next;
        }
    return dummy.next;
    }
}

不添加dummy:

/**
 * 不添加虚拟节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    while (head != null && head.val == val) {
        head = head.next;
    }
    // 已经为null，提前退出
    if (head == null) {
        return head;
    }
    // 已确定当前head.val != val
    ListNode pre = head;
    ListNode cur = head.next;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return head;
}

设计链表

力扣题目链接

题意：

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

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

707示例

思路

这道题目就是设计链表的五个接口：

  • 获取链表第index个节点的数值
  • 在链表的最前面插入一个节点
  • 在链表的最后面插入一个节点
  • 在链表第index个节点前面插入一个节点
  • 删除链表的第index个节点
//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

反转链表

力扣题目链接

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

思路

利用双指针进行方向的反转，则不需要另外创建一个新的链表了；

/**
 * 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) {
        ListNode pre =null;
        ListNode cur =head;

        ListNode tmp;
        while(cur != null) {
            tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur =tmp;
        }
        return pre;
    }
}

两两交换链表中的节点

力扣题目链接

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

24.两两交换链表中的节点-题意

思路

正常模拟就好；

// 虚拟头结点
class Solution {
  public ListNode swapPairs(ListNode head) {

    ListNode dummyNode = new ListNode(0);
    dummyNode.next = head;
    ListNode prev = dummyNode;

    while (prev.next != null && prev.next.next != null) {
      ListNode temp = head.next.next; // 缓存 next
      prev.next = head.next;          // 将 prev 的 next 改为 head 的 next
      head.next.next = head;          // 将 head.next(prev.next) 的next，指向 head
      head.next = temp;               // 将head 的 next 接上缓存的temp
      prev = head;                    // 步进1位
      head = head.next;               // 步进1位
    }
    return dummyNode.next;
  }
}

删除链表的倒数第N个节点

力扣题目链接

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

19.删除链表的倒数第N个节点

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

输入：head = [1], n = 1 输出：[] 示例 3：

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

思路

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了

class Solution {    public ListNode removeNthFromEnd(ListNode head, int n) {        ListNode dummy = new ListNode(0);        dummy.next = head;        ListNode fast  = head;        ListNode slow = dummy;        for(int i = 0 ; i<n;i++){            fast = fast.next;        }        while(fast!=null){            fast = fast.next;            slow = slow.next;        }        slow.next = slow.next.next;        return dummy.next; //这里不返回head是防止特殊情况的发生    }}

链表相交

力扣题目链接(opens new window)

给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。

示例 1：

输入：listA = [4,1,8,4,5], listB = [5,0,1,8,4,5]

输出：Reference of the node with value = 8

输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

思路

难点在于读懂题目，题目意思其实就是求两个链表的交点节点的指针，这个交点相等并不是数值相等，而是指针相等；

如图进行模拟：

面试题02.07.链表相交_1

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

面试题02.07.链表相交_2

然后对curA和curB进行比较，返回结果即可；

/** * Definition for singly-linked list. * public class ListNode { *     int val; *     ListNode next; *     ListNode(int x) { *         val = x; *         next = null; *     } * } */public class Solution {    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {        int lenA = 0;        int lenB = 0;        ListNode curA = headA;        ListNode curB = headB;        while(curA != null){            lenA++;            curA = curA.next;        }        while(curB != null){            lenB++;            curB = curB.next;        }        curA = headA;        curB = headB;        if(lenB>lenA){            int lenTmp = lenA;            lenA = lenB;            lenB =lenTmp;            ListNode nodeTmp = curA;            curA = curB;            curB = nodeTmp;        }        int gap = lenA - lenB;        while(gap-- > 0){            curA = curA.next;        }        while(curA != null && curB!=null){            if(curA == curB){                return curA;            }            curA = curA.next;            curB = curB.next;        }        return null;    }}

环形链表II

力扣题目链接(opens new window)

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

思路

首先要做的是判断是否有环，用快慢指针法，快指针步进2，慢指针步进1，如果有环必然会相遇，然后推算一下两个指针走过的路径会发现在相遇的节点到入口节点的路径与头节点到入口节点的路径是有固定公式的，特殊情况下是一样的，可以根据这个进行求解：

/** * Definition for singly-linked list. * class ListNode { *     int val; *     ListNode next; *     ListNode(int x) { *         val = x; *         next = null; *     } * } */public class Solution {    public ListNode detectCycle(ListNode head) {        ListNode fast = head;        ListNode slow = head;        while(fast !=null && fast.next!=null){            slow =slow.next;            fast = fast.next.next;            if(slow == fast){                ListNode index1 = fast;                ListNode index2 = head;                while(index1 != index2){                    index1 = index1.next;                    index2 =index2.next;                }                return index1;            }        }        return null;    }}
学海无涯le做舟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表基础题大全（一）
冷血之心的博客
03-09 3677
关于链表的常见操作，所做的一个总结。
链表基础及常见面试题
897371388
05-14 134
基础知识 链表是一种很常见的数据结构，在每个节点都保存了指向下一个节点的指针。与顺序表相比，链表插入元素的复杂度是O(1)，查找一个节点或者访问特定节点编号的元素的复杂度是O(n)；顺序表插入元素的复杂度是O(n)，而查找的复杂度是O(1)。使用链表可以不必事先知道数据的大小，但是增加了指针域，加大了内存的开销。链表有三种类型：单向链表、双向链表和循环链表。 链表节点的定义 type...
【链表】：必写的四道基础题
幻想有一天能进大厂
04-25 1287
这里给大家推荐必写的四道单链表基础题！！！
链表基础题目
不屈土豆的博客
11-15 323
探究链表特性及基础问题。
链表基础题（删除问题，反转链表，快慢指针）
weixin_45841522的博客
09-17 217
1. 题目：力扣237删除链表中的节点 思考： 从链表里删除一个节点 node 的最常见方法是修改之前节点的 next 指针，使其指向之后的节点。但是这道题我们无法访问我们想要删除的节点（node) 之前的节点. void deleteNode(struct ListNode* node)看它传入的参数是一个节点,所以我们只需要将想要删除的节点的值替换为它后面节点中的值，然后删除它之后的节点就可以了。但是要注意，题目中有提示（给定的节点为非末尾节点并且一定是链表中的一个有效节点）所以我们才可以用->
【数据结构】链表入门基础题
weixin_72437555的博客
12-03 420
最近笔者正在准备实验室的考核，用一些时间简单刷了一些leetcode中的简单链表题，其中遇到了些许问题并通过自己的思考加以解决，现以此博客写下自己的题解并记录自己刷题的心得。如有错误，请不吝指出。为了方便读者写博客，也为了方便读者读博客，现在下方放出笔者定义的链表存储结构与用尾插法创建链表的代码链表存储结构 尾插法创建链表 二、链表的基础操作 首先在做题之前，希望读者能够仔细阅读以下的基础操作，后续笔者的例题与以下的操作息息相关思路： ①声明一个指针指向链表第一个有效节点，也就是头结点后面的第一个结点。初始
链表深度解析：从基础到高级算法
最新发布
07-05
链表基础知识： 提供了链表的基本概念讲解，涵盖不同类型的链表结构和它们的基本操作。 列举了链表领域的经典题目，供读者通过实践来加深理解。 链表排序： 探讨了链表排序的相关知识，分析了不同排序算法在链表上...
2009上半年试题分析与解答
03-24
《2009上半年试题分析与解答》是一个针对软件技术水平考试（简称“软考”）的复习资料，其中包含了该年度上半年所有科目的试题解析。这份资料的重要性在于它提供了对考试试题的深入理解和解答方法，有助于考生更好地...
中科大算法设计与分析王子磊试卷.rar
07-10
首先，2018年的试题（2018.docx）可能涵盖的主要内容包括基础数据结构（如数组、链表、栈、队列、树、图）、排序算法（冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等）、搜索算法（如二分查找、深度...
算法设计与分析基础实验
12-25
《算法设计与分析基础实验》 算法设计与分析是计算机科学中的核心课程，它涉及到如何高效地解决问题，以及如何衡量和证明解决方案的效率。在这个实验中，我们将深入探讨这一领域，通过实践操作来提升我们的算法设计...
链表基础算法题
weixin_45017459的博客
04-02 356
1.反转链表（重点） 反转链表： 输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 假设链表为 1→2→3→∅，反转后为 ∅←1←2←3。 在遍历链表时，将当前节点的next指针改为指向前一个节点。 由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。 在更改引用之前，还需要存储后一个节点。最后返回新的头引用。 public ListNode reverseList(ListNode head) { ListNode pre=null; Li
基础链表练习（附详细注释）
04-08
实现一个带头结点的字符串链表，每插入一个字符串，链表会对其进行按字典进行排序。 重复插入的字符串自动忽略。 通过索引号可以获取到对应位置上的字符串。 移除一个特定的元素 返回链表中存储的字符串个数
链表-基础算法题
CenShell
12-27 609
0.基本概念 单链表结点的结构 struct ListNode { int data; struct ListNode* next; ListNode() {} ListNode(int data, ListNode* next = NULL) : data(data), next(next) {} }; 有无头结点只对尾插法的操作有影响，对头插法没有影响 ⚠️尾插法一定要提供尾指针 1.添加/删除链表节点 添加值为 x 的结点 带头结点的递增有序的单链表 L 添加一个值为 x 的结
链表基础题大全（二）
冷血之心的博客
03-12 2264
关于常见链表的操作总结二
Day04--链表基础题（二）
qq_44934596的博客
02-22 154
链表基础题，快慢指针
链表基础面试题（部分）
weixin_43767691的博客
04-15 190
//三个指针反转单链表 struct ListNode *reverserList(struct ListNode *head) { struct ListNode *p1 = NULL; struct ListNode *p2 = head; struct ListNode *p3 = head->next; while (p2 != NULL) { ...
链表课后练习题（基础）
ling_wang的博客
12-10 2638
//13人围成一圈，报到3退出，找到留在圈子中的人原来的序号 /* #include<cstdio> #include<iostream> #include<cstdlib> using namespace std;#define len sizeof(struct student)struct student { int num; struct student *next; };s
单链表基础面试题（上篇）
lucky52529的博客
01-14 339
1.移除链表元素 struct ListNode* removeElements(struct ListNode* head, int val)//移除链表元素 { if (head == NULL) return head; struct ListNode* cur = head; struct ListNode* prev = NULL; while (cur) { struc...
计算机软件技术基础复习：链表操作与时间复杂度
本资源是一份计算机软件技术基础的期末复习题PDF，涵盖了线性表的存储结构、时间复杂度、数据...这份复习题涉及了基本的数据结构概念、时间复杂度分析以及链表操作，对于巩固计算机软件技术基础课程的学习非常有帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值