[数据结构](线性表之单链表，搞懂这几个题，链表基础就算搞懂了)

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

文章目录

🥇1.反转链表

在以下的问题中都需要一个测试类，TestDemo.java文件,测试方法功能。以及实现链表功能的函数，这些功能方法都存放在MyLinkedList.java文件中

TestDemo.java文件：

 public class TestDmeo {
    public static void main(String[] args) {
         MylinkedList mylinkedList = new MylinkedList();
    }
}

在MyLinkedList.java文件中新建一个链表和打印链表

    public Node head; //建立头结点
    public void createList() {
        Node node1 = new Node(6);
        Node node2 = new Node(1);
        Node node3 = new Node(8);
        Node node4 = new Node(7);
        Node node5 = new Node(10);
        //把每个节点穿起来
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        this.head = node1;
    }

     //实现打印链表
    public void print(){
      if(this.head == null){
          return;
      }
      Node cur = this.head;
      while(cur!=null){
          System.out.print(cur.val+" ");
          cur = cur.next;
      }
    }

接下来就到了实现以下功能的时候了
反转链表
在这里插入图片描述

🚩那让我们先看看翻转后的链表吧
在这里插入图片描述

📄算法思想之尾插法：

  1. 判断链表是否为空，为空就返回null
  2. 如果链表中只有一个节点，那就直接返回这个节点
  3. 建立一个新的头节点并把它赋为null 即 Node newhead = null
  4. 建立跟随节点cur,并赋予cur = this.head
  5. 既然要翻转链表，那么我们需要把原链表的头结点的next 赋为 null。即cur.next = null,因为在翻转链表过程中要遍历链表所以我们要保存节点Node curNext = cur.next,翻转链表cur.next = newhead ,然后新头结点也依次向后遍历newhead = cur，跟随节点遍历链表cur = curNext;直到cur==null为止，遍历链表结束

🚩老规矩，看图说话：
在这里插入图片描述

💯代码：

 class Solution {
    public ListNode reverseList(ListNode head) {
    if(head == null || head.next == null)//如果链表为null，或者链表中只有一个节点
    {
        return head;
    }
    //建立新的头结点
    ListNode newhead = null;
    //建立跟随节点
    ListNode cur = head;
    while(cur!=null){
       ListNode curNext = cur.next; //保存节点
       cur.next = newhead;  //把旧的头结点 this.head.next = null
       newhead = cur;
       cur = curNext;
    }
    return newhead;
    }
}

🥇2.返回链表的中间节点

在这里插入图片描述
📄算法思想：

1. 判断链表是否为空；
2. 用快慢指针的方法解答此题，先把快指针和慢指针都初始化为this.head,即Node fast = this.head,Node slow = this.head;
3. 然后快指针在链表中一次遍历两步，慢指针一次遍历一步，即fast = fast.next.next;slow = slow.next就这样当快指针把链表遍历完的时候，慢指针刚刚遍历到链表的一半，即慢指针在链表的中间节点，返回这个中间节点
4. 遍历条件：单链表中节点个数为奇数时，限制 条件为fast.next!=null,当节点个数为偶数时，限制条件为fast!=null

🚩看图说话：
在这里插入图片描述
💯代码：

 class Solution {
    public ListNode middleNode(ListNode head) {
    if(head == null){
        return head;
    }
    ListNode fast = head;
    ListNode slow = head;
    while(fast!=null && fast.next!=null){
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
    }
}

🥇3.返回链表中倒数第k个节点

在这里插入图片描述
📄算法思想：

1. 先判断链表是否为空，为空就返回null
2. 还是依据快慢指针的思想，让快指针先走k-1位，然后快指针和慢指针一块一步走，直到把链表遍历完

🚩看图说话：
在这里插入图片描述
💯代码：

 class Solution {
    public int kthToLast(ListNode head, int k) {
    if(head == null){
        return -1;
    }
    ListNode fast = head;
    ListNode slow = head;
    int count = 0;
    while(count!=k-1 && fast!=null && fast.next!=null){
        count++;
        fast = fast.next;
    }
    while(fast!=null && fast.next != null){
        fast = fast.next;
        slow = slow.next;
    }
    return slow.val;
    }
}

🥇4.判断链表是否有环

在这里插入图片描述
📄算法思想：

  1. 判断链表是否为空
  2. 利用快慢指针思想，定义快慢指针，起先都赋为head,快指针一次走两步，慢指针一次走一步，如果在遍历链表的时候快指针节点的地址和慢指针节点的地址相同，则证明链表有环

🚩看图说话：
在这里插入图片描述

💯代码：

 public class Solution {
    public boolean hasCycle(ListNode head) {
        //判断链表是否有环
        ListNode slow = head; //定义慢指针
        ListNode fast = head; // 定义快指针
        while(fast!=null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast){
                return true;
            }
        }
        return false;
    }
}

🥇5.合并两个有序链表，为一个有序大链表

在这里插入图片描述
📄算法思想：

1. 已知两个链表中节点中的数值为升序排序。
2. 当其中一个链表为空时，返回另一个链表，当两个升序链表都为空时，返回null
3. 定义一个虚拟节点newhead ，在定义一个跟随节点temp ，两个链表中的节点的数值进行比较，较小的进入新链表，例如假设此时headA节点的数值较小那么，temp.next = headA，然后原链表继续向后遍历headA = headA.next,跟随节点再遍历下一个链表节点temp = temp.next

🚩看图说话：
在这里插入图片描述
💯代码：

 class Solution {
    public ListNode mergeTwoLists(ListNode headA, ListNode headB) {
    
    //建立虚拟节点
    //建立长链表跟随节点
    ListNode newhead = new ListNode(-1);
    ListNode temp = newhead;
    if(headA == null){
        return headB;
    }
    if(headB == null){
        return headA;
    }
    if(headA == null && headB == null){
        return null;
    }
    while(headA!=null && headB!=null){
        if(headA.val<headB.val){
            temp.next = headA;
            headA = headA.next;
            temp = temp.next;
        }else{
            temp.next = headB;
            headB = headB.next;
            temp = temp.next;
        }
    }
    //遍历到一个链表的尾节点
    if(headA == null){
        temp.next = headB;
    }
    if(headB == null){
        temp.next = headA;
    }
    return newhead.next;
    }
}

🥇6.已知链表有环，返回链表的入环节点

在这里插入图片描述
📄算法思想：

1. 判断链表是否为空，为空就返回null
2. 还是根据快慢指针的思想，慢指针slow = head,快指针fast =head,快指针一次遍历两个节点，慢指针一次遍历一个节点，快慢指针遍历链表，如果在遍历途中fast == slow 说明链表有环，否则无环，相遇的时候说明快指针遍历的链表长度是慢指针遍历的两倍，当相遇的时候，把slow置为head,slow和fast一块一步走，直到fast == slow

🚩看图说话：
在这里插入图片描述
💯代码：

 public class Solution {
    public ListNode detectCycle(ListNode head) {
        //如果链表为空
        if(head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
               break;
            }
        }
        if(fast == null || fast.next == null){
            return null;
        }
        slow = head;
        while(slow != fast){
            slow = slow.next;
            fast = fast.next;
        }
         return slow;
    }
}

🥇7.判断链表是否是回文链表

在这里插入图片描述
📄算法思想：

1. 先找到链表的中间节点
2. 翻转中间节点之后的链表
3. 分别利用两个指针遍历没有翻转的一小段链表和翻转过得一小段链表，并且比较他们节点中的数值是否相等

🚩看图说话：
在这里插入图片描述
💯代码：

 class Solution {
    public boolean isPalindrome(ListNode head) {
      //先找到中间节点，再把中间节点之后的节点进行翻转链表，然后对撞指针
      //定义快慢指针
      if(head == null){
       return false;    
      }
      ListNode fast = head;
      ListNode slow = head;
      //快指针一次走两步，慢指针一次走一步
      while(fast != null && fast.next != null){
          fast = fast.next.next;
          slow = slow.next;
      }
      //找到中间节点
      //返回中间节点之后的链表
      //定义一个跟随节点
      ListNode cur = slow.next;
      while(cur!= null){
          //保存节点
          ListNode curNext = cur.next;
          //翻转、
          cur.next = slow;
          slow = cur;
          cur = curNext;
      }
      //翻转完毕
      //对撞
      while(head!=slow){
        if(head.val != slow.val){
            return false;
        }
        if(head.next == slow){
            return true;
        }
          head = head.next;
          slow = slow.next;
      }
      if(head == slow){
          return true;
      }
      return false;
    }
}

🥇8.分割链表

在这里插入图片描述
📄算法思想：

1. 判断被分割链表是否为空，为空返回null
2. 分别建立两个新的头节点headAstart和headBstart，和尾节点headAend和headBend
3. 在被分割链表中遍历，把小于固定值的节点存放在链表headAstart中，headAend在子链表A中遍历，大于固定值的节点存放在链表headBstart中，headBend在子链表B中遍历。
4. 最后连接两个链表，headAend.next = headBstart;,把子链表headBstart中的尾节点next赋为null

🚩看图说话：
在这里插入图片描述
💯代码：

 public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        //算法思想：建立两个子链表，当在主链表中遍历的时候，遍历到比
        //x小的节点时，把这个节点添加到子链表headA中，大于x添加到子
        //链表headB中，然后两个节点进行拼接
        ListNode cur = pHead; //建立主链表跟随节点
        ListNode headAstart = null;
        ListNode headAend = null;
        
        ListNode headBstart = null;
        ListNode headBend = null;
        while(cur!=null){
            if(cur.val < x){
                if(headAstart == null){
                    headAstart = cur;
                    headAend = cur;
                }else{
                    headAend.next = cur;
                    headAend = headAend.next;
                }
            }else{
                 if(headBstart == null){
                    headBstart = cur;
                    headBend = cur;
                }else{
                    headBend.next = cur;
                    headBend = headBend.next;
                 }
            }
            cur = cur.next;
        }
       if(headAstart == null){
           return headBstart;
       }
        if(headBstart == null){
            return headAstart;
        }
        headAend.next = headBstart;
        if(headBend!=null){
            headBend.next = null;
        }
    return headAstart;
    }
}

🥇9.删除链表的中间节点

在这里插入图片描述
注意这道题，很搞人哟，一定要仔细读题。要不然就和博主起先一样被耍了，以为要找到链表的真正中间节点，在进行删除，结果就被耍了，题目中的中间节点的意思是 除头节点和尾节点都算中间节点，读到这里有没有恍然大悟呀，哈哈哈

📄回来了，回来了，看看它的算法思想：

1. 在所传来的参数中node表示的是要删除的节点，所以我们要删除这个节点。
2. 让删除节点后的节点，覆盖删除节点。node.val = node.next.val;node.next = node.next.next;

🚩看图说话：
在这里插入图片描述

💯代码：

 class Solution {
    public void deleteNode(ListNode node) {
    //如果删除节点为头结点
    //删除节点
    node.val = node.next.val;
    node.next = node.next.next;
    }
}

🥇10.链表相交，返回链表链表的相交节点

在这里插入图片描述
📄算法思想：

1. 先判断链表是否为空，一共有两个链表，如果其中有一个链表为空的话，那么就们有相交节点，就返回null
2. 跟随节点cur，遍历链表，计算两个链表的长度lenA,lenB，默认lenA计算的是长链表的长度，lenB计算的是短链表的长度，pl = this,head,ps = this,head,让长链表先走lenA-lenB步，然后pl和ps就到了同一起跑线，让ps和pl一块走，直到pl == ps 退出

🚩看图说话：
在这里插入图片描述
💯代码：

 public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //当个链表长度不一样时，求出差值
        int lenA = 0;
        int lenB = 0;
        ListNode pl = headA;
        ListNode ps = headB;
        while(pl!=null){
            lenA++;
            pl = pl.next;
        }
         while(ps!=null){
            lenB++;
            ps = ps.next;
        }
        //恢复节点
        pl = headA;
        ps = headB;
        int len = lenA - lenB;
        if(len<0){
        pl = headB;
        ps = headA;
        len = lenB - lenA;
        }
        //长链表先走差值步
        for(int  i = 0;i<len;i++){
            pl = pl.next;
        }
        //同时走
        while(pl!=ps && pl != null && ps != null){
            pl = pl.next;
            ps = ps.next;
        }
        if(pl == ps && ps != null && pl != null){
            return pl;
        }
        return null;
    }
}

🥇11.从尾到头打印链表

在这里插入图片描述📄算法思想：

1. 判断链表是否为空
2. 遍历链表，利用循环从尾到头打印链表，以数组形式返回
🚩看图说话：
在这里插入图片描述
💯代码：

 class Solution {
    public int[] reversePrint(ListNode head) {
    //遍历链表，求出链表长度
    int len = 0;
    ListNode cur = head;
    while(cur!=null){
        len++;
        cur = cur.next;
    }
    cur = head;
    int i = 0;
    int []array = new int[len];
    for(i = len-1;i>=0;i--){
    array[i] = cur.val;
    cur = cur.next;
    }
    return array;
    }
}

🥇12.删除链表中重复的节点

在这里插入图片描述
📄算法思想：

1. 判断链表是否为空，为空就返回null
2. 创建一个虚拟节点，防止第一个节点中的数值，为重复数值
3. 遍历链表，如果遇到相同的节点就跳过。cur.val == cur.next.val 就跳过

🚩看图说话：
在这里插入图片描述
💯代码：

 public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        //创建一个虚拟节点
        ListNode newhead = new ListNode(-1);
        ListNode temp = newhead;
        ListNode cur = pHead; //创建跟随节点
        while(cur!=null){
            //如果遇到节点数值相同的数，就跳过
            if(cur.next!=null && cur.val == cur.next.val){
                while(cur.next!=null && cur.val == cur.next.val){
                    cur = cur.next;
                }
                cur = cur.next;
            }else{
                temp.next = cur;
                temp = temp.next;
                cur = cur.next;
            }
        }
        temp.next = null;
        return newhead.next;
    }
}

ps 记得点 👍哦， 🤞

小周学编程~~~
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
数据结构（一）线性链表、非线性链表、稀疏数组与队列、单向链表
codinglover5的博客
08-07 3173
数据结构和算法的关系 ➢数据data结 构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了 数据结构.学好数据结构可以编写出更加漂亮更加有效率的代码。 ➢要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. ➢程序=数据结构+算法 ➢数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。 线性链表和非线性链表 数据结构包括:线性结构和非线性结构。 线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在- -对- - 的线性关系（a[0]=3
数据结构 学习笔记之：线性表——顺序表、静态链表、动态链表(单链表、双链表、单循环链表、双循环链表，链式栈、链式队列)——基础概念大扫盲！
可乐虎博客
03-12 2381
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 更多原创“uC/OS-II学习笔记之：系列”基础及嵌入式相关知识详解，请
单链表
Eriksen的博客
10-15 472
1.单链表 下一个节点的引用即是存放下个节点的地址 以便于连成一个链表 初始化属性 提供一个带有data next 的构造方法 以便于后面使用 class Node{ public int data; public Node next; public Node(int data){ this.data=data; //next为一个引用 因此须默认为null 以便于后面使用 this.next=null; } .
链表python基础知识
热门推荐
qq_44941689的博客
01-10 1万+
跟着datawhale刷力扣，以下基本来自于其文档，感谢 链表基本类型 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。即「链表」 是实现线性表的链式存储结构的基础。 单链表每个数据元素占用若干存储单元的组合称为一个「链节点」，还要存放一个指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址，该地址被称为「后继指针 next」。 双向链表（Doubly Linked List）：链表的一种，也叫做双链表。它的
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构课程作业 单链表 双链表 线性表 堆栈 等课程编程作业
08-07
在本课程作业中，我们重点关注了几种基本的数据结构：单链表、双链表、线性表和堆栈，同时也涉及到二叉树。这些概念在解决实际问题，特别是优化算法效率时起着关键作用。 首先，单链表是一种线性数据结构，其中每个...
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
数据结构实验报告 线性表 串 队列 栈.doc
04-01
本实验报告的主题围绕线性表、串、队列和栈这四种基本的数据结构展开，旨在通过实践加深对这些概念的理解。线性表是一种线性的数据结构，其中元素按特定顺序排列，每个元素只有一个前驱和一个后继，除了第一个和最后...
c语言数据结构几个链表操作List.zip
05-14
本文将深入探讨“线性表顺序结构”和“链表”这两种数据结构，以及在C语言中如何进行操作。我们将涵盖无空头单链表和有空头单链表的基本定义、初始化、计数、插入、删除和清空链表等关键概念。 首先，线性表是一种...
算法力扣刷题记录 五十九【450.删除二叉搜索树中的节点】
danaaaa的博客
07-25 1278
删除节点，在左右子树不为空的情况，处理稍微复杂。
代码随想录算法训练营第二十二天|回溯算法part01
qq_43456971的博客
07-25 729
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1320
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
大模型算法备案流程最详细说明【流程+附件】
cybtec的博客
07-25 977
大模型备案,模型服务协议 1.大模型备案 2.大模型算法备案 3.大模型网信办备案 4.网信办大模型备案 5.AI大模型备案制度 6.大模型 备案 7.大模型备案要求 8.大模型备案管理制度 9.算法备案和大模型备案区别
代码随想录算法训练营第22天-leetcode-回溯算法part01：
最新发布
weixin_65180740的博客
07-25 1133
column的赋值过程：*column是正常数组，先为*column开辟空间，*column【第几个，<returnsize】=ans【第几个】有多少个二层元素。示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4],放入path的过程需要用循环一个个放入，直接=path的话，后面会随path修改而修改。示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1684
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
学习C语言第12天（数组练习）
2301_79600945的博客
07-24 579
把任意数字从中间拆分拆分后的乘积之和等于自身，则是一个水仙花。例如：655=6*55+65*5。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 2886
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
2024秋招算法
weixin_43364551的博客
07-22 2128
根据代码随想录和力扣进行算法训练的笔记
线性表与单链表插入操作详解
"这篇内容主要讨论了数据结构中的线性表，特别是单链表的插入操作。线性表是一种基本的数据结构，其中的元素按照线性顺序排列，每个元素有一个直接前驱和一个直接后继。单链表是实现线性表的一种方式，通过节点之间...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小周学编程~~~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值