【数据结构】单链表实现

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

单链表

链表

顺序表的缺点就是当插入或删除元素时，可能会涉及大量元素的移动，并且在添加元素时，可能会造成空间浪费，所以又出现了另外一种数据结构 — 链表结构。

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接实现的，由结点（或节点）组成，结构如下：

链表结构

注意：

  1. 链式结构在逻辑上是连续的，物理上不一定连续。
  2. 结点一般是从堆上申请的。
  3. 两次申请的空间可能连续，也可能不连续。

实际中的链表结构有很多种，例如：单向或双向、带头或不带头、循环或非循环，通过组合就可以达到 8 种链表结构。

单向结构或双向结构：

单向和双向结构

带头或不带头：

带头和不带头结构

循环或非循环：

循环和非循环结构

通过组合可以得到 8 种：单向带头循环、单向带头非循环、单向不带头循环、单向不带头非循环、还剩四种把单向改成双向即可，但是我们只用掌握 不带头单向非循环 和 不带头双向非循环 即可，只要掌握这两种，其他结构的操作方法都类似。

实现不带头单向非循环链表

☞☞☞ 不带头单向非循环链表实现：

首先定义一个单链表类：这里的头结点只是用来指向链表中的第一个节点，相当于C语言中的指针，而带头结点的链表中，头结点是一个真正的结点，头结点中的 val 域可以存放表长信息或者不存储信息，而 next 部分则存放第一个节点的地址。

public class MySingleList {
   static class ListNode  {
        public int val;       //存储的数据
        public ListNode  next;//存储下一结点的地址

        public ListNode (int val) {
            this.val = val;
        }
    }
    public ListNode head;   //代表当前链表的头结点的引用

}

定义好单链表后，我们创建一个单链表。

打印单链表的方法：

//创建单链表
public void createLink() {
    ListNode node1 = new ListNode(11);
    ListNode node2 = new ListNode(22);
    ListNode node3 = new ListNode(33);
    ListNode node4 = new ListNode(44);
    //让结点指向结点，形成链表
    node1.next = node2;
    node2.next = node3;
    node3.next = node4;
    //头结点指向第一个节点
    head = node1;
}

//打印单链表
public void display() {
//生成一个新结点，否则在遍历时，head移动后就找不到链表的头了。
    ListNode cur = head;
    while (cur != null) {
        System.out.print(cur.val + " ");
        cur = cur.next;
    }
    System.out.println();
}

先看运行结果：

display结果

执行过程：

创建单链表

打印单链表过程：

display过程

判断单链表是否包含关键字 key：

contains方法

运行结果：

contains运行结果

求单链表的长度：

//单链表的长度
public int size() {
    ListNode cur = head;
    int count = 0;
    while (cur != null) {
        count++;
        cur = cur.next;
    }
    return count;
}

运行结果：

size运行结果

头插法：

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

先看运行结果：

头插运行结果

头插实现过程：

头插实现过程

尾插法：

//尾插法
public void addLast(int data) {
    ListNode node = new ListNode(data);
    //如果链表里没有结点,那新结点就是头结点
    if (head == null) {
        head = node;
        return;
    }
    ListNode cur = head;
    //找到最后一个结点
    while (cur.next != null) {
        cur = cur.next;
    }
    //让最后一个结点指向新结点
    cur.next = node;
}

运行结果：

尾插结果

尾插实现过程：

尾插实现过程

任意位置插入，第一个数据节点为 0 号下标：

//任意位置插入
public void addIndex(int index, int data) {
	//检查插入的位置是否合法
    checkIndex(index);
    //如果在下标0位置插入，就相当于头插
    if (index == 0) {
        addFirst(data);
        return;
    }
    //如果下标和链表的长度一样，就相当于尾插
    if (index == size()) {
        addLast(data);
        return;
    }
    //其他情况：找到index前一个位置
    ListNode cur = head;
    while (index - 1 > 0) {
        cur = cur.next;
        index--;
    }
    ListNode node = new ListNode(data);
    node.next = cur.next;
    cur.next = node;
}

运行结果：

任意位置插入运行结果

任意位置插入实现过程：

在这里插入图片描述

删除第一次出现关键字为 key 的结点：

//删除第一次出现关键字为key的结点
public void remove(int key) {
    //如果head为空，直接返回
    if (head == null) {
        return;
    }
    //如果head的值就为key，只需让head指向下一个结点
    if (head.val == key) {
        head = head.next;
    }
    //找到值等于key的前一个结点
    ListNode cur = searchPre(key);
    //判断返回来的结点是否为空
    if (cur==null){
        return;
    }
    //修改指向
    cur.next=cur.next.next;
}

private ListNode searchPre(int key) {
    ListNode cur = head;
    //遍历到最后一个节点
    while (cur.next != null) {
        //如果下一节点的值等于key的话就返回当前节点
        if (cur.next.val == key) {
            return cur;
        }
        cur = cur.next;
    }
    //链表遍历完也没有key就返回null
    return null;
}

运行效果：

remove运行效果

remove 实现过程：

remove实现过程

实现删除所有值为 key 的节点：

public void removeAllkey(int key) {
    if (head == null) {
        return;
    }
    //指向前一节点
    ListNode prev = head;
    //指向当前节点
    ListNode cur = head.next;
    //遍历
    while (cur != null) {
        if (cur.val == key) {
            prev.next = cur.next;
            cur = cur.next;
        } else {
            prev = cur;
            cur = cur.next;
        }
    }
    //此时只有头结点没有判断是否等于key，等于就指向下一结点
    if (head.val == key) {
        head = head.next;
    }
}

运行结果：

removeAll

实现过程：

removeall分析

动图演示：

removeAll-GIF

清空链表方法：

public void clear() {
	//只需让头结点置为null即可
    head = null;
}

以上就是单链表的基本实现，而 删除所有值为 key 的节点 方法的实现也是力扣上面的题目 ☛☛☛[移除链表元素]

链表题目

反转链表

下面再来一道代码题加深对单链表的操作： ☛☛☛ Leetcode — 反转链表。

题目要求：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

反转前的链表：11 -> 22 -> 33 -> 44

反转前的链表

反转后的链表：44 -> 33 -> 22 -> 11

反转后的链表

我们可能会想遍历到最后，再将其指向前一个结点，直到第一个节点，但这是单链表，不是双链表，只知道下一个结点，不知道上一个结点。所以我们在遍历的同时，采用头插法将每个结点插入到链表的头部完成链表反转。

反转链表

代码：

public ListNode reverseList(ListNode head) {
	//如果链表为空，返回null
    if(head == null){
        return null;
    }
    //只有一个节点
    if(head.next == null){
        return head;
    }
    	//让 cur 指向头结点的下一个结点
        ListNode cur = head.next;
        //将 head 的next域置为 null
        head.next = null;
        //cur结点不为空 就继续
        while(cur != null){
        	//让curNext 指向cur节点的下一结点，防止到不到后面的结点
            ListNode curNext = cur.next;
            //将 cur 的next域指向 head
            cur.next = head;
            //head前移
            head = cur;
            //cur找到剩余的结点，继续反转
            cur = curNext;
        }
        return head;
}

链表的中间结点

题目链接：链表的中间结点。
题目要求：
链表的中间结点

对于这题，我们使用的是快慢指针，快的走两步，慢的走一步，两个同时走，当快的走到终点时，慢的才走了一半，此时慢指针指向的就是链表的中间结点。

public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
        	//快的走两步
            fast = fast.next.next;
            //慢的走一步
            slow = slow.next;
        }
        return slow;
    }

奇数个结点链表和偶数个节点链表：

链表中间结点

链表中倒数第k个结点

题目链接：链表中倒数第k个结点。
题目描述：

倒数k个节点描述
题目解析：

倒数k个节点

代码：

public ListNode FindKthToTail(ListNode head, int k) {
        //如果k小于0  或者链表为空返回null
        if (k < 0 || head == null)
            return null;

        //定义快慢指针
        ListNode fast = head;
        ListNode slow = head;

        //快指针走 k-1 步
        while (k - 1 != 0) {
            fast = fast.next;

            //如果 fast 为null，说明没有倒数k个节点
            if (fast == null)
                return null;
            k--;
        }

        //快指针走完 k-1 步后， 快慢同时走，快的走到链表最后，慢的就是倒数 k个
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

合并两个有序链表

题目链接：合并两个有序链表。
题目描述：

题目描述

实现过程：

合并有序链表过程
代码：

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newHead = new ListNode();
        ListNode tmp = newHead;
        while(list1 != null && list2 != null){
        //谁的值小，tmp 就指向谁，然后自己在往后
            if(list1.val < list2.val){
                tmp.next = list1;
                list1 = list1.next;
                tmp = tmp.next;
            }else{
                 tmp.next = list2;
                list2 = list2.next;
                tmp = tmp.next;
            }
        }
        //谁不等于空，就等于谁
        if(list1 != null){
            tmp.next = list1;
        }
        if(list2 != null){
            tmp.next = list2;
        }
        //最后返回新结点的next即可
        return newHead.next;
    }

链表的回文结构

题目链接：链表的回文结构。
题目描述：

回文结构

分析过程：
在这里插入图片描述

代码：

public boolean chkPalindrome(ListNode A) {
        if (A == null) {
            return false;
        }
        //只有一个节点也是回文结构
        if (A.next == null) {
            return true;
        }
        ListNode fast = A;
        ListNode slow = A;
        //找到中间结点，此时的中间结点就是slow
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        //将中间结点后的结点反转，cur也走到了链表最后
        ListNode cur = slow;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }

        //头结点A和最后节点slow不相遇，就继续进行判断
        while(A != slow){
            //只要值不等，就不是回文结构
            if(A.val != slow.val){
                return false;
            }
            //头结点的下一结点是 slow结点，也是回文
            if(A.next == slow){
                return true;
            }
            A = A.next;
            slow = slow.next;
        }
        //此时 结点A 和 结点slow 相遇，说明全程都是相等的，也就是回文结构，返回true
        return true;
    }

CM11 链表分割

题目链接：链表分割
题目描述：现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

也就是原来是什么顺序，重新排列后还是什么顺序，只是把小于和大于 x 的结点分开了：
链表分割状态

分析过程：

链表分割分析过程

代码：

public ListNode partition(ListNode pHead, int x) {
        //bs 和 be 之间存放小于 x 的结点
        ListNode bs = null;
        ListNode be = null;
        //as 和 ae 之间存放大于等于 x 的结点
        ListNode as = null;
        ListNode ae = null;
        //从头结点开始遍历
        ListNode cur = pHead;
        while (cur != null) {
            //小于x的情况
            if (cur.val < x) {
                //小于x进来，判断当前是不是小于x的第一个节点
                if (bs == null) {
                //如果是第一个节点，bs 和 be都指向这个节点
                    bs = cur;
                    be = cur;
                } else {
                    //不是则使用尾插法添加数据
                    be.next = cur;
                    be = be.next;
                }
            } else {    //大于等于x的情况
                //同样判断是不是大于等于x的第一个节点，如果是第一个节点，as和bs都指向这个节点
                if (as == null) {
                    as = cur;
                    ae = cur;
                } else {
                    //同样使用尾插法添加数据
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        //不能保证有节点小于x，如果没有小于x的结点，返回大于x结点部分
        if (bs == null) {
            return as;
        }
        //如果能走到这里，说明有节点小于x，那就让小于x的最后一个结点和大于等于x的结点串起来
        be.next = as;

        if (as != null) {
            ae.next = null;
        }
        return bs;
    }

相交链表

题目链接：相交链表
题目描述：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。具体描述可点击链接查看。

分析过程：

相交链表分析过程

代码：

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //链表A的长度
        int lenA = 0;
        //链表B的长度
        int lenB = 0;
        ListNode pl = headA;
        ListNode ps = headB;
        while (pl != null){
            lenA++;
            pl = pl.next;
        }
        while (ps != null){
            lenB++;
            ps = ps.next;
        }
        //pl 和 ps指向已更改，需重新赋值
        pl = headA;
        ps = headB;
        //两个链表相差的个数
        int count = lenA - lenB;
        //如果count小于0，那么lenA个数就比lenB小，所以重新赋值，让pl指向的为两个链表中较长的一个
        //count也为正数
        if (count < 0){
            pl = headB;
            ps = headA;
            count = lenB - lenA;
        }
        //长的链表先走 count 步
        while (count != 0){
            pl = pl.next;
            count--;
        }
        //长的走完count步后，一起走直到相遇，或者在不相交时，两个都走到null退出
        while (pl != ps){
            pl = pl.next;
            ps = ps.next;
        }
        //相遇就是相交结点，其中一个为空，说明没有相交点，上面也走到了null
        return pl;
    }

环形链表

题目链接：环形链表
题目描述：给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 如果链表中存在环 ，则返回 true 。 否则，返回 false 。

例如：

环形链表题目描述

分析过程：

环形链表解析

代码：

public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast!= null && fast.next != null){
            //fast走两步
            fast = fast.next.next;
            //slow走一步
            slow = slow.next;
            //相遇就是有环
            if (fast == slow)
                return true;
        }
        //退出说明fast为空，也就是没有环
        return false;
    }

环形链表 II

题目链接：环形链表 II
题目描述：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

例如：

环形链表描述

分析过程：

在这里插入图片描述

代码：

public ListNode detectCycle(ListNode head) {
		//定义快慢指针
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
        	//快的走两步
            fast = fast.next.next;
            //慢的走一步
            slow = slow.next;
            //到达相遇点
            if(fast == slow){
                break;
            }
        }
        //到这里说明没有环
        if(fast == null || fast.next == null){
            return null;
        }
        //其中一个指针回到起点
        fast = head;
        while(fast != slow){
        	//两个指针同时一步一步走
            fast = fast.next;
            slow = slow.next;
        }
        //相遇就是环入口结点，返回其中一个即可
        return slow;
    }

以上就是单链表的实现以及牛客网和力扣上的一些关于链表的经典题目。

JANG1024
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
单链表的实现
qq_38291820的博客
08-21 1013
单链表的结构图 单链表的功能实现：增加，删除，查找，改写，销毁，排序，逆置 单链表的代码优化
【数据结构】单链表
xing1584114471的博客
10-10 331
（近期我在学习数据结构，于是我自己整理了单链表、循环单链表、双向链表、双向循环链表的相关代码，以巩固这段时间的学习，也希望能够帮助初学者，希望大家在阅读以下代码时发现问题纠正于我，一起探讨） LinkLIst.h #ifndef __LINKLIST_H #define __LINKLIST_H #include <stdio.h> #include <stdlib.h&...
【 数据结构 】单链表的实现 - 详解（C语言版）
热门推荐
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
单链表的基本实现(详细图解+解说)
Eliauk_U的博客
03-16 4888
目录 一.前言： 二.链表的结构实现: 三.单链表的功能实现-增删查..... 1.结点的申请 2.数据的头插 3.数据的打印 4.数据的尾插 5.数据的头删 6.数据的尾删 7.数据的查找 8.数据的指定插入和指定删除 9.链表的销毁 四.后言 一.前言： 我们都知道，顺序表是一块连续的可以存放数据的存储空间，其可以通过下标或指针解引用的方式快速访问某个位置的数据，但是由于空间的连续性，想要灵活的插入和删除数据便较为困难。 区别于顺序表，链表由一个个独立的可以存放数..
链表的实现
m0_73592835的博客
12-28 554
链表的实现
【数据结构】单链表的实现
VHhhbb的博客
03-03 2346
【数据结构】单链表的实现
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
java 数据结构单链表的实现
08-30
"Java 数据结构单链表的实现" Java 数据结构单链表是 Java 语言中的一种基本数据结构，用于存储和操作链表数据。在 Java 中，单链表可以通过定义链表节点和链表操作工具类来实现。 一、链表节点的定义 链表节点是...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构单链表的实现（C++）
06-07
单链表是计算机科学中一种基础且重要的数据结构...在实际应用中，单链表常常用于实现动态数据结构，例如队列和栈，或者作为其他复杂数据结构的基础。理解并熟练掌握单链表的实现对学习更高级的数据结构和算法至关重要。
【数据结构】---【单链表完整介绍和实现】
m0_74044018的博客
04-05 793
单链表的实现逻辑是什么？他的实现功能基本全部实现！详细讲解！
单链表实现
kunmu6666的博客
10-02 619
C语言实现数据结构链表
数据结构：单链表的实现（最强解释版）
qq_44851228的博客
07-24 544
链表的概念及其结构 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链表接次序实现的。 链表不能将元素直接存储在不连续的内存空间，因为此结构中下一个元素未知，因此除了要存储元素的信息外，还必须要存储元素下一个节点的位置（地址） 链表的结构 链表可以分为下面三类。组合起来共有八种结构 1.单向、双向 2.带头节点、不带头 3.循环、不循环 ...
数据结构之链表的详细实现
qq_62905847的博客
09-20 1912
详细解释实现Java数据结构中的链表
什么是链表，如何实现？（单链表篇）
Welcome to Claffic's blog ! ! !
03-01 2738
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的.
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 390
【代码】c语言（7.23）
c语言实现数据结构单链表
06-06
好的，下面是一个使用C语言实现单链表的例子： ```c #include #include typedef struct node { int value; struct node *next; } Node; typedef struct linked_list { Node *head; } LinkedList; void add...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值