数据结构之链表的详细实现

已于 2022-09-29 21:19:55 修改
阅读量1.8k 收藏 13
点赞数 1
分类专栏： Java 数据结构 文章标签： 链表 数据结构
于 2022-09-20 01:00:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62905847/article/details/126940275
版权

文章目录


在我们实现过顺序表后，不难发现顺序表在实现增加删除时要进行 整体的前搬或后移，对于任意位置的插入十分不方便，这里我们就需要链表来进行更好的实现。

一、对于链表的基本解释

抽象形式：
在这里插入图片描述

概念：
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

注：
1.链式结构在逻辑上是连续的，但是在物理上不是连续的。
2.实现中结点一般是在堆上申请出来的。
3.堆上申请出来的结点可能连续，也可能不连续。

链表的结构可以分为3大块：
1.单向或双向。
2.带头或不带头。
3.循环或非循环。
排列组合下来可以有8种不同的组合，但是相对简单且基础的是，无头结点的单向链表。

二、无头结点的单向链表的实现

1.基本框架的构建

在进行各项方法实现之前，我们最先需要了解的是结点的形式，如图：
在这里插入图片描述
不难看出，每一个结点都是一个独立的空间，那么，在实现结点的程序时，就可以将其定义为一个内部类开辟申请空间，代码如下：

static class ListNode{
	//实现数据域
	public int val;
	//实现指针域
	public ListNode next;
	//实现数据域的构造方法
	public ListNode (int val){
		this.val = val;
	}
}
//实现一个头结点用来指向链表的第一个元素
	public ListNode head;

接下来，我们要了解链表需要实现哪些方法：
1.头插法
2.尾插法
3.插入任意位置
4.查找是否包含某些数据在链表中
5.删除指定的第一个出现的元素
6.删除链表中指定出现的全部元素

为了我们更好的实现不同的方法，我们可以最先实现打印方法，便于我们更加直观实现方法。代码如下：

public void display(){
	//定义一个car来作为遍历的指针
	ListNode car = this.head;
	while(car != null){
		System.out.print(car.val+ " ");
		car = car.next;
	}
	System.out.println();
}

2.头插法

逻辑解释：
首先，假设已经有了两个结点，如图：
在这里插入图片描述
头插，顾名思义就是要将元素放到链表的头部，再将head指针指向新的元素。

操作如图：
在这里插入图片描述
步骤1 ：首先要将头结点指向的元素地址传递给新的节点
步骤2：再将 head 指针指向新的 node 元素。

代码如下：

//头插法
public void addFirst(int data){
	ListNode node = new ListNode(data);
	//将头结点指向的元素的地址传给新结点的next
	node.next = head;
	//将新结点的地址传给head
	head = node;
}

代码测试：

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addFirst(1);
        signalLinkedList.addFirst(2);
        signalLinkedList.addFirst(3);
        signalLinkedList.addFirst(4);
        signalLinkedList.display();
    }
}

在这里插入图片描述
不难理解，因为是头插法，数字在打印出来时顺序正好相反。

3.尾插法

逻辑实现：
同理假设有两个结点，如图：
在这里插入图片描述
这里插入的逻辑思考并不难，直接将链表最后一个元素的 next 存储新结点node 的地址即可，但是，这里我们就需要考虑如何找到链表的最后一个元素，我们可以定义一个 car 专门来寻找它。

操作如图：
在这里插入图片描述
步骤1：找到链表最后一个元素
步骤2：将新结点的地址传递给最后一个元素。

代码如下：

public void addLast(int data){
	ListNode node = new ListNode(data);
	ListNode car = this.head;
	//这里要判断是否为第一个元素
	if(car == null){
		this.head = node;
	}
	else{
		while(car.next != null){
			car = car.next;
		}
		car.next = node;
	}
}

代码测试：

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(1);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(3);
        signalLinkedList.addLast(4);
        signalLinkedList.display();
     }
}

在这里插入图片描述

4.任意位置插入

在实现这个操作之前，我们需要先实现一个可以确定链表长度的方法，这个在之后会用到。

代码如下：

public int size(){
	int count = 0;
	ListNode car = this,head;
	while(car != null){
		count++;
		car = car.next;
	}
	return count;
}

逻辑解释：

首先，假设已经有了一串链表，如图：
在这里插入图片描述
这里插入就有很多要注意的地方，插入的位置不能小于链表长度的最小值，不能大于链表的长度。至于，在合适位置插入的方法，逻辑不难理解，要知道，先接后，在连前。

操作如图：
在这里插入图片描述
步骤1：定义一个 car 指针找到要插入位置的上一个位置。
步骤2：将 car 指向的后继结点的地址传递给 node。
步骤3：将 node 的地址传递给上一个元素。

代码如下：

这里判断合法性还需要一个方法实现：

//合法性判断方法
public class IndexWrongFulException extends RuntimeException {
    public IndexWrongFulException() {
    }

    public IndexWrongFulException(String message) {
        super(message);
    }
}

public void addIndex(int index,int data){
	if(index < 0 || index > size()){
		System.out.println("index不合法");
		throw new IndexWrongFulException("index不合法");
	}
	//当index为0时等于头插法
	if(index == 0){
		addFirst(data);
		return;
	}
	//当index为链表长度时可以用尾插法
	if(index == size()){
		addLast(data);
		return;
	}
	//这里可以定义一个内部私有方法来确定car的位置
	private ListNode findIndexSub(int index){
		ListNode car = this.head;
		while(index != 0){
			car = car.next;
			index--;
			//随着index-- car的位置在不断向前
		}
		return car;
	}

	//实现正常插入操作
	ListNode node = new ListNode(data);
	ListNode car = findIndexSub(index);
	node.next = car.next;
	car.next = node;
}

代码测试：

1.测试报错代码

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(1);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(3);
        signalLinkedList.addLast(4);
        signalLinkedList.addIndex(-1,99);
        signalLinkedList.display();
    }
}

在这里插入图片描述
2.测试正常代码

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(1);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(3);
        signalLinkedList.addLast(4);
        signalLinkedList.addIndex(2,99);
        signalLinkedList.display();
    }
}

在这里插入图片描述

5.查找 是否 包含某些数据在链表中

逻辑解释：

这里的是否表明这个方法是只要证明是否有该数字，所以为 boolern 类型，只需要定义一个 car 指针在链表中进行扫描即可。

代码实现：

public boolern contains(int key){
	ListLnode car = this.head;
	while(car != null){
		if(car.val == key){
			return true;
		}
		car = car.next;
	}
	return false;
}

6.删除 指定的第一个 出现的元素

逻辑解释：

同样，首先假设有一串链表。
在这里插入图片描述
假设，这里要删除的元素为 2 ，呢么根据要求只要可以删去第一个 2 就可以了，同样，这里还要考虑链表长度为0，链表中没有要删除的元素的情况，除过这些操作，正常删除的逻辑也不难理解，如下图解释：

在这里插入图片描述
逻辑1：定义一个car指针找到要删除的值
逻辑2：将要删除的值的 next 存放的下一个元素的地址传递给 car.next

代码实现：

public void remove(int key){
	//判断如果为空
	if(this.head == null){
		return 0;
	}
	//如果第一个元素就是要删除的数值
	if(this.head == key){
		this.head = this.head.next;
		return;
	}
	//这里定义一个内部方法用来实现对要删除元素位置的查找
	private LinkNode findRomve(int key){
		LinkNode car = this.head;
		while(car != null){
			if(car.next.val == key){
				return car;
			}
			car = car.next;
		}
		return null;
	}
	LinkNode car = findRomve(key);
	if(car == null){
		System.out.println("没有找到要删除的值");
		return;
	}
	car.next = car.next.next;
}

代码测试：

1.没有找到要删除的值

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(1);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(4);
        signalLinkedList.remove(99);
    }
}

在这里插入图片描述
2.正常删除

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(1);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(4);
        signalLinkedList.remove(2);
        signalLinkedList.display();
    }
}

在这里插入图片描述

7.删除链表中 指定出现的 全部元素

逻辑解释:

同样，我们首先有一个链表，如图：
在这里插入图片描述

同样假设这里要删除的值为 2 ，这里可以定义两个指针，一前一后，前面的指针进行搜索，后面的指针进行跨越。如图：

在这里插入图片描述
逻辑1：定义两个指针确定位置
逻辑2：car 发现是要删除的结点，将下一个结点的地址传递给 prev 指向的 next
逻辑3：car 向后移动
逻辑4：与逻辑 2 相同
逻辑5：与逻辑 3 相同
逻辑6：car 指向的元素不是要删除的元素，将 prev 移动过去。
逻辑7：在判断头结点的值也为要删除的元素后，将 head 指向 prev。

代码实现：

public void removeAllKey(int key){
	//首先判断链表是否存在
	if(this.head == null){
		return;
	}
	ListNode car = this.head.next;
	ListNode prev = this.head;
	while(car != null){
		if(car.val == key){
			//直接跨过要删除的数据
			prev.next = car.next;
			car = car.next;
		}
		else{
			//出现不需要删除的数据时
			prev = car;
			car = car.next;
		}
	}
	//除头结点查找完后，检查头结点是否为要删除元素
	if(this.head.val == key){
		this.head = prev;
	}
}

代码测试：

public class Test {
    public static void main(String[] args) {
        SignalLinkedList signalLinkedList = new SignalLinkedList();
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(2);
        signalLinkedList.addLast(4);
        signalLinkedList.removeAllKey(2);
        signalLinkedList.display();
    }
}

在这里插入图片描述

8.总结

到这里链表的实现已经基本完成，并不是很复杂，但是逻辑分析十分重要，最后，在这里实现一个清空链表就圆满完成了！

    public void clear(){
        this.head = null;
    }

感谢您的阅读，如有问题，欢迎指正。

Mo_yang.
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言数据结构——链表的实现及其基本操作
希望自己从编程小白变成大佬
04-06 4085
顺序表的问题及思考中间/头部的插入删除，时间复杂度为O(N)增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面我们给出了链表的结构，让我们来看看吧。
链表的实现
qq_44888950的博客
11-05 562
文章目录1 链表1.1 链表的概念及结构1.2 链表的实现 1 链表 1.1 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 之所以叫链表，因为其结构就类似于链条，每个节点包括一个value和指向下一个节点的引用。 1.2 链表的实现 这里主要实现的是不带头的非循环链表 创建节点： class ListNode1{ public int val; public ListNode1 next; //有参构造，给val赋
单链表的基本实现(详细图解+解说)
Eliauk_U的博客
03-16 4828
目录 一.前言： 二.链表的结构实现: 三.单链表的功能实现-增删查..... 1.结点的申请 2.数据的头插 3.数据的打印 4.数据的尾插 5.数据的头删 6.数据的尾删 7.数据的查找 8.数据的指定插入和指定删除 9.链表的销毁 四.后言 一.前言： 我们都知道，顺序表是一块连续的可以存放数据的存储空间，其可以通过下标或指针解引用的方式快速访问某个位置的数据，但是由于空间的连续性，想要灵活的插入和删除数据便较为困难。 区别于顺序表，链表由一个个独立的可以存放数..
【链表的学习】实现链表的几种方法
cchengjie007的博客
01-01 972
1.静态链表 const int N = 10000; //按需要定义静态链表的空间大小 struct node{ //单向链表 int id; //这个结点的id int data; //数据 int nextid; //指向下一个结点的id }n
一文解决用C语言实现一个链表（全都是细节）
胡坚涛的博客
01-06 1678
链表是指数据使用一个一个的结点连接起来的数据结构，这样的数据结构中不像顺序表一样，顺序表中不同的数据在内存中的存储空间是相邻的，链表中的相邻结点在内存中的存储位置是没有任何关系的，每一个链表都是由许多的结点组成的，而一个链表，我们需要一个对应的头指针来管理这个链表，也就是说，如果我们拥有一个链表的头指针，那么我们就可以拿到这个链表中的所有的结点，在此基础上，如果我们还学会对链表中的结点进行一些常见的操作（增删查改），那么我们就可以熟练使用链表来解决现实中的问题了
Python数据结构之链表实现
最新发布
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
JavaScript数据结构之链表的实现
10-20
总之，理解和掌握链表的实现对于提升JavaScript编程能力，特别是在设计复杂数据结构和算法时，都是非常有益的。在JavaScript中，我们可以利用面向对象编程的思想，创建自定义的链表类来满足特定需求。
C语言 数据结构之链表实现代码
01-20
最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！ 什么是链表 简单的说，链表就是由多个结点离散分配，彼此通过指针...
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
用C语言实现单链表操作
xuzhougeng blog
02-02 6577
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
链表的两种实现方法
float_wind的博客
08-29 579
链表是一种常用的数据结构，对于链表主要有两种实现实现方法，分别是指针和数组，指针实现则不需要连续的存储空间，元素分布在不同的地址，通过指针找到，而数组实现的话，就需要分配一段连续的存储空间，而且对于元素也有数量限制。   1、指针实现，即链式结构#include #include struct Node { int value; struct Node *next; }; typedef
《数据结构》| 链表的具体实现（超详细）
KeepCodeing
06-22 371
线性表链式存储的具体实现，单链表如何实现增删查改？单链表，循环链表，双端链表如何实现增删查改？以及链表各个扩展之间的联系是什么？
链表的完整实现
qq_21110983的博客
02-08 504
我们知道可以单纯的使用c来模拟一个vector动态数组，可是我们上一次并没有实现，可以传递任意数据来进行数组保存的效果，那我们本次就实现一个动态储存的链表结构并且让他能够接受任何数据。 那么什么是链表呢？ 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 简单来说链表就像一串珠子一样，是靠着一条线进行连接的。 首先我们明确一下链表和普通的数组的优点： 链表的优点在于每次插入数据不需要把后面的数据进行大量的移动，而是直接把需要插入的数据和插入位置的前
链表的通用实现方式
lixinglaing的博客
05-01 167
在链表的使用时，结构对象所包含的数据各不相同，所以在链表的存储需要针对不同的链表对象重复编写相应的存储方法，能不能实现一种通用的方式，能够针对不同的结构对象，实现统一的存储方法？当然能。 一般我们在存储链表时，都会存储链表对象结构的首地址，也就是结构指针。在计算机中，对于指针，在32位机器上，实际就是四个字节的存储单元，里面存储了结构的首地址。可以利用这一点，在对象结构的首元素上做文章。 首先...
数据结构学习笔记——线性表之单链表（c语言实现）
luotuoxiansheng的博客
10-31 4982
1.概念 链式存储结构：是指把数据元素存放在任意内存未被占用的存储单元里，这组存储单元可以是连续的，也可以是不连续的。 大概就是这样： 因此，为了表示每个数据元素a1，与其直接后继数据元素 a2 之间的逻辑关系，对数据元素a来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。 对此有如下几个概念： 数据域 指针域 指针(链) 头指针 存储数据...
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
数据结构：链表实现（c）
weixin_44525246的博客
03-05 592
链表为数据存储常用方法，以下是基于C语言实现普通单向链表。其他双向链表循环链表在此基础上做些许变化。关于是否使用表头的问题，本链表不包含表头，表头可记录链表信息，能降低使用复杂性，按需使用。 声明部分： #ifndef _LIST_H #define _LIST_H typedef int ELEMENT; //define whatever your want type enum { ERROR = 0, SUCSSE }; typedef struct {
单链表的基本操作c语言实现
gongdileidechouzhu的博客
02-25 1万+
#include<stdio.h> #define false 0 #define ok 1//定义节点的结构 typedef struct node{ int data; struct node *next; }node; typedef struct node *linklist;//初始化链表，创建一个链表并赋值 void creatlist(linklist *l,int n
如何实现单链表的增删操作
付朝俊的博客
07-27 1024
链表作为最基础的数据结构，在程序设计中具有非常重要的作用，起存储特点如下:可以用任意一组存储单元来存储单链表中的数据元素（存储单元可以是不连续的），而且，除了存储每个数据元素ai 外，还必须存储指示其直接后继元素的信息，这两部分信息组成的数据元素aI 的存储映像成为结点。N个结点连接在一块被称为链表，当结点只包含其后继结点的信息的链表就被称为单链表，如下图所示. 在java 语言中可定义如下
c语言数据结构之链表
11-03
链表是一种常见的数据结构，它在计算机科学中有广泛的应用。在C语言中，链表常常用于实现动态内存分配、函数调用栈、多项式运算等问题。单向链表是一种基本的链表结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的插入操作可以分为在链表头部插入和在链表中间插入两种情况。在链表头部插入可以通过新建一个节点，将其指针指向原来的头节点，再将头指针指向新节点来实现。在链表中间插入可以先找到要插入位置的前一个节点，然后新建一个节点，将其指针指向后一个节点，再将前一个节点的指针指向新节点来实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值