02--图解数据结构之单链表实现容器

最新推荐文章于 2022-11-06 19:26:38 发布
最新推荐文章于 2022-11-06 19:26:38 发布
阅读量280 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30447263/article/details/83034726
版权

链表是一种线性的数据结构
是一种最简单的动态数据结构

优点：  动态创建，节省空间  
        头部添加容易  
缺点：空间上不连续，查找困难。只能从头开始一个一个找

对于单链表：
链表类Node的成员变量有：T类型的数据和Node类型的节点，并且成员变量node指向下一个节点。
为了统一节点的操作，通常在链表最前面添加一个虚拟头结点
9414344-15790f6c1f520541.png
链表.png
9414344-c2fc778350576d74.png
一个链表.png 
我想再强调一下数据结构的作用是为数据寻找一个合适的载体，让数据的操作更加快捷。
Node只不过是一个辅助工具，并不会暴露在外。它与数据相对应，又使数据按链式排布，
操纵节点也就等于操纵数据，就像提线木偶，我们操作的是"观众"所看不见的线，而不是木偶的各个肢体本身。
一、单链表实现集合：SingleLinkedGroup
1.节点类的设计
 /**
  * 内部私有节点类
  * @param <T>
  */
 private class Node<T>{
     /**
      * 节点数据元素
      */
     public T el;
     
     /**
      * 下一节点的引用
      */
     public Node next;
     
    public Node(T el, Node next) {
        this.el = el;
        this.next = next;
    }
    
    @Override
    public String toString() {
        return el.toString();
    }
 }
2.SingleLinkedGroup继承自Group 基类见第一篇
public class SingleLinkedGroup<T> extends Group<T> {

    /**
     * 虚拟头结点
     */
    private Node headNode;

    public SingleLinkedGroup() {
        clear();
    }

    @Override
    public void add(int index, T el) {

    }

    @Override
    public T remove(int index) {
        return null;
    }

    @Override
    public void clear() {
        headNode = new Node(null, null);
        size = 0;
    }

    @Override
    public T set(int index, T el) {
        return null;
    }

    @Override
    public T get(int index) {
        return null;
    }

    @Override
    public int[] getIndex(T el) {
        return new int[0];
    }

    @Override
    public Group<T> contact(int index, Group<T> group) {
        return null;
    }
    /Node类见上方
}
二、底层节点操作
1.定点插入

1---新节点的next指向目标节点
2---目标节点的上一节点(即data1)的next指向新节点
3---增加size

9414344-cb77d0214ebdd9b3.png
添加节点.png 
/**
 * 在指定链表前添加节点
 *
 * @param index 索引
 * @param el    数据
 */
private void addNode(int index, T el) {
    Node<T> target = getNode(index - 1);
    //新建节点，同时下一节点指向target的下一节点
    Node<T> tNode = new Node<>(target.next, el);
    //目标节点的next指向新节点
    target.next = tNode;
    size++;
}
2.定点获取

思路：链表查找只能一个一个挨着找，就像排队报数样。

/**
 * 根据索引寻找节点
 * @param index 索引
 * @return 节点
 */
private Node<T> getNode(int index) {
    //声明目标节点
    Node<T> targetNode = headNode;
    for (int i = 0; i < index; i++) {
        //一个挨着一个找，直到index
        targetNode = targetNode.next;
    }
    return targetNode;
}
3.定点修改
/**
 * 修改节点
 * @param index 节点位置
 * @param el 数据
 * @return 修改后的节点
 */
private Node<T> setNode(int index, T el) {
    Node<T> node = getNode(index);
    node.el = el;
    return node;
}
4.定点移除

思路：目标节点的前一节点的next指向目标节点的下一节点(即把元素孤立)
把目标节点的next指向为null

9414344-4c11cfdac14f2829.png
链表移除节点.png 
/**
 * 移除指定索引的节点
 *
 * @param index 索引
 * @return 删除的元素
 */
private T removeNode(int index) {
    //目标节点前一节点
    Node<T> targetPrev = getNode(index - 1);
    //目标节点
    Node<T> target = targetPrev.next;
    //目标节点前一节点的next指向目标节点下一节点
    targetPrev.next = target.next;
    target.next = null;
    size--;
    return target.el;
}
三、集合类外部访问接口实现
1、增：添加--add
@Override
public void add(int index, T el) {
    // index可以取到size，在链表末尾空位置添加元素。
    if (index+1 < 0 || index > size) {
        throw new IllegalArgumentException("Add failed. Illegal index");
    }
    addNode(index + 1, el);
}
2.删:移除--remove
@Override
public T remove(int index) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Remove failed. Illegal index");
    }
    return removeNode(index + 1);
}
3.该：修改--set
@Override
public T set(int index, T el) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Set failed. Illegal index");
    }
    return setNode(index + 1, el).el;
}
4.查：获取--get
@Override
public T get(int index) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Get failed. Illegal index");
    }
    //消除headNode影响，所以+1
    return getNode(index + 1).el;
}
5.测试
SingleLinkedGroup<String> list = new SingleLinkedGroup<>();
list.addFirst("特");
list.addLast("烈");
list.addFirst("风");
list.addFirst("张");
list.add(2, "杰");
list.set(2, "捷");
System.out.println(list);
//head: 张->风->捷->特->烈->NULL
for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i));//张风捷特烈
}
list.remove(2);
//head: 张->风->特->烈->NULL
System.out.println(list);
list.clear();
System.out.println(list);//head: NULL
四、其他操作
1.根据指定元素获取匹配索引
@Override
public int[] getIndex(T el) {
    //临时数组
    int[] tempArray = new int[size];
    //重复个数
    int index = 0;
    int count = 0;
    Node node = headNode.next;
    while (node != null) {
        if (el.equals(node.el)) {
            tempArray[index] = -1;
            count++;
        }
        index++;
        node = node.next;
    }
    //将临时数组压缩
    int[] indexArray = new int[count];
    int indexCount = 0;
    for (int i = 0; i < tempArray.length; i++) {
        if (tempArray[i] == -1) {
            indexArray[indexCount] = i;
            indexCount++;
        }
    }
    return indexArray;
}
2.定点连接两个链表式集合
 @Override
 public Group<T> contact(int index, Group<T> group) {
     SingleLinkedGroup<T> linkedGroup = (SingleLinkedGroup<T>) group;
     //获取待接入链表 头结点
     Node firstNode = linkedGroup.getHeadNode().next;
     //获取待接入链表 尾结点
     Node lastNode = linkedGroup.getLastNode();
     //获取目标节点
     Node<T> target = getNode(index+1);
     //获取目标节点的下一节点
     Node targetNext = target.next;
     //获取目标节点的next连到 接入链表 头结点
     target.next = firstNode;
     //待接入链表 尾结点连到 目标节点的下一节点
     lastNode.next = targetNext;
     return this;
 }
 
public Node getHeadNode() {
    return headNode;
}
public Node getLastNode() {
    return getNode(size);
}
2.其他方法测试:
        SingleLinkedGroup<String> linkedGroup = new SingleLinkedGroup<>();
        linkedGroup.addLast("a");
        linkedGroup.addLast("b");
        linkedGroup.addLast("a");
        linkedGroup.addLast("c");
        linkedGroup.addLast("a");

        System.out.println(linkedGroup);
        //head: a->b->a->c->a->NULL

        //获取a元素的所有索引位置
        int[] as = linkedGroup.getIndex("a");
        for (int a : as) {
            System.out.print(a+" ");//0 2 4
        }

        //删除a元素第一次出现的地方---
        linkedGroup.removeEl("a");
        System.out.println(linkedGroup);
        //head: b->a->c->a->NULL

        //查看a元素是否存在
        boolean b = linkedGroup.contains("a");
        System.out.println(b);//true

        //删除所有a元素出现的地方---
        linkedGroup.removeEls("a");
        System.out.println(linkedGroup);
        //head: b->c->NULL
        
        SingleLinkedGroup<String> linkedGroup2 = new SingleLinkedGroup<>();
        linkedGroup2.addLast("1");
        linkedGroup2.addLast("3");
        linkedGroup2.addLast("2");
        linkedGroup.contact(1, linkedGroup2);
        System.out.println(linkedGroup);
        //head: b->c->1->3->2->NULL
五、时间测试：单链表式集合：SingleLinkedGroup测试
方法\数量复杂度10001000010W100W1000W
addLastO(n)0.0029秒0.1096秒9.1836秒--------
addFirstO(1)0.0002秒0.0009秒0.0036秒0.5039秒3.1596秒
addO(n)----------
removeLastO(n)0.0012秒0.1009秒8.9750秒--------
removeFirstO(1)0.0001秒0.0016秒0.0026秒0.0299秒0.1993秒
removeElO(n)----------
removeElsO(n)----------
removeO(n)----------
clearO(1)----------
setO(n)----------
getO(n)----------
getIndexO(n)----------
后记、
1.声明：

[1]本文由张风捷特烈原创,各图均由本人亲自所画，转载请注明
[2]欢迎广大编程爱好者共同交流
[3]个人能力有限，如有不正之处欢迎大家批评指证，必定虚心改正
[4]你的喜欢与支持将是我最大的动力

2.连接传送门：

更多数据结构知识欢迎访问:图解数据结构
项目源码均在我的github/DS：欢迎star
张风捷特烈个人网站，编程笔记请访问：http://www.toly1994.com

3.联系我

QQ:1981462002
邮箱：1981462002@qq.com
微信：zdl1994328

4.欢迎关注我的微信公众号，最新精彩文章，及时送达：
9414344-c474349cd3bd4b82.jpg
公众号.jpg
张风捷特烈
关注
数据结构——“单链表“ 深度刨析单链表（图解+代码）
weixin_44278698的博客
04-26 1995
单链表线性表和单链表关系单链表概述链表结点类型描述：单链表的基本程序单链表的基本操作（运算）一、 单链表的创建1.1 创建空链表 再插入值（头插法建表）1.2 创建链表时 由用户输入值 （尾插法建表）二、单链表的遍历三、单链表的插入3.1 头插法3.2 尾插法 线性表和单链表关系 线性表的链式存储结构就是链表 单链表概述 将线性表L=(a0 ,a1 ，······，an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立它们之间的联系，所得到的存储结构为链表结构，表中元素ai的结
单链表应用------根据两个升序单链表,生成一个降序单链表（头插法）
goging的博客
09-23 2672
2018/9/28  17:19    数据结构笔记(一) 数据结构中一种特别重要的结构就是链表，和链表有关的应用有很多，很多语言的容器api的底层实现就是链表，所以掌握链表也是一名计算机级专业的学生必备，下面我们就来看看一下单链表的小应用-----------将两个升序单链表,合并为一个降序单链表（不拆分升序链表），这里将会涉及的知识有:       1.单链表创建以及插入       2...
数据结构 —— 单链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-06 3414
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
由链表实现的容器
fulinwsuafcie的专栏
05-12 1843
在java中用链表实现一个容器，将对象添加到容器中并打遍历该容器 首先，定义一个类 Node 作为链表的一个结点，我们知道每个节点都有两部分内容： 1，该结点保存的内容  2，指向下一个结点的指针 package com.dp.iterator; public class Node { private Object data; private Node next; publi
功能：以单链表为底层创建自己的容器
qq_45080791的博客
09-21 80
以单链表为底层创建自己的容器 //单链表 public class MySingleList { //1.创建结点 class Node { Object data;//存储的信息 Node next; public Node(Object data, Node next) {//构造方法：初始化一个新的结点 this.next = next; this.data = data;
基于数组的容器类实现 和 基于链表结构的容器类实现
weixin_30493321的博客
12-11 381
1. 数据结构 　　概念 ：数据结构是计算机存储、组织数据的方式。 简单理解：可以看成是对数据存储的一种方式　　　　　 　　常见的数据结构: 　　　　　　　　　　数组 　　　　　　　　　　链表:一种动态的线性的数据结构 , 优点： 动态创建，节省空间，头部添加容易 , 缺点：空间上不连续，查找困难。只能从头开始一个一个找 　　　　　　　　　　队列：FIFO 先进先出原则 ...
图解数据结构使用C++范例程序
11-04
《图解数据结构使用C++范例程序》是一本深入浅出的数据结构学习资源，它以C++语言为工具，通过实例程序详细讲解了各种重要的数据结构及其应用。在这个压缩包中，你将找到一系列与数据结构相关的C++源代码，帮助你更...
【NOI题解】 3.2数据结构之指针和链表
赞美月亮的专栏
12-21 1663
NOI题目地址(3.2数据结构之指针和链表)：http://noi.openjudge.cn/ch0302/ 这部分的题解出于练习指针和链表的目的，我都是自定义的链表结构。实际上C++提供了STL list链表容器，对于链表元素的增删查反转等操作都有封装好的接口，直接使用将会得到非常简洁的代码。1748:约瑟夫问题分析:用循环链表解决约瑟夫环问题 关键在于： - 删除链表结点的操作 -
不会数据结构？24张图让你彻底弄懂它，还不会你来打我！
12-31 468
数据结构想必大家都不会陌生，对于一个成熟的程序员而言，熟悉和掌握数据结构和算法也是基本功之一。数据结构本身其实不过是数据按照特点关系进行存储或者组织的集合，特殊的结构在不同的应用场景中往往会带来不一样的处理效率。 常用的数据结构可根据数据访问的特点分为线性结构和非线性结构。线性结构包括常见的链表、栈、队列等，非线性结构包括树、图等。数据结构种类繁多，本文将通过图解的方式对常用的数据结构进行理论上的介绍和讲解，以方便大家掌握常用数据结构的基本知识。 一、数组 数组可以说是最基本最常见的数据结构。数组一般用来
关键路径例题图解_图解！九大常见数据结构被24张图给安排的明明白白
weixin_39662432的博客
10-21 1631
数据结构想必大家都不会陌生，对于一个成熟的程序员而言，熟悉和掌握数据结构和算法也是基本功之一。数据结构本身其实不过是数据按照特点关系进行存储或者组织的集合，特殊的结构在不同的应用场景中往往会带来不一样的处理效率。常用的数据结构可根据数据访问的特点分为线性结构和非线性结构。线性结构包括常见的链表、栈、队列等，非线性结构包括树、图等。数据结构种类繁多，本文将通过图解的方式对常用的数据结构进行理论上的介...
[原创]用模板写的一个单链表容器(可轻松改造成一个库文件 @ C++编程.txt
11-01
[原创]用模板写的一个单链表容器(可轻松改造成一个库文件 @ C++编程.txt
链表数据结构图解 和 代码实现
csshuke的专栏
03-14 667
项目中经常会用到LinkedList集合来存储数据，打算写一篇LinkedList的源码解析，而LinkedList是基于链表结构存储数据的，这篇博文将解析链表数据结构，包括单向链表和双向链表；1：单向链表：单向链表的链表对象维护了一个 first 引用，该引用指向节点链表中的第一个节点对象，每个节点对象维护一个 next 引用，next引用指向下一个节点对象；（这里注意：是引用指向的是节点对象：...
单向链表实现元素存取容器
qq_43293392的博客
04-23 732
基于链表结构存取元素的方法API定义： package com.bjsxt; /** * @Author:Dai * @Date:2022/4/23 基于链表结构存取元素的方法API定义 */ public interface MyList<E> { void add(E element); E get(int index); int size(); E remove(int index); } 基于单向链表实现元素存取的容器： pa
【C++操作手册】利用C++内置STL容器实现单链表各种功能定义
CSDN 精品推荐
05-22 471
文章目录初始化单链表`InitList(&L)`求表长`Length(L)`按值查找`LocateElem(L,e)`按位查找`GetElem(L,i)`插入操作`ListInsert(&L,i,e)`删除操作`ListDelete(&L,i,e)`输出操作`PrintList(L)`判空操作`Empty(L)`销毁操作`DestroyList(&L)` 初始化单链表InitList(&L) #include <iostream> #include &lt
STL链表容器：自制list（链表）容器
最新发布
qq_43591406的博客
11-06 1003
自制STL链表容器。
STL 利用模板自制链表容器
xueHui
02-26 284
#include <stdexcept> using namespace std; // list<T>代表双向链表类，链表里的每个节点是T类型的数据 template <class T> class list { public: // 缺省构造, 空链表 list():m_head(NULL), m_tail(NULL){} // 拷贝构造, 用一个存在的链表拷贝构造一个新的链表 list(list const that):m_head(
链表实现容器的底层方法
st199563的博客
10-19 310
public class LinkedList {     private Node first;     private Node last;          private int size;          public void add(Object obj){     if(first==null){     Node n = new Node();     n.s
List双向链表容器
tengxiaoming的专栏
05-21 722
List双向链表容器一、原理list是双向链表的一个泛化容器。作为一种序列容器，它的数据元素可通过链表指针串接成逻辑意义上的线性表。不同于采用线性表顺序存储结构的vector和deque容器，list双向链表中任一位置的元素查找、插入和删除，都具有高效的常数阶算法时间复杂度O（1）。为了支持前向和反向访问 list 容器的元素，如图所示，list 采用双向循环的链表结构组织数据元素
数据结构1.链表的建立
Be__yond的博客
11-20 632
链表的建立主要是分两种，一种为头接法，一种为尾接法。头接法比较简单，但是输入和输入的循序是相反的，个人不是很喜欢。尾接法相对比较复杂，好处就是，输入输出的顺序是不变的。         主要讲解一下尾接法。先建立结构体struct ListNode { int data; struct ListNode *next; };         尾接法的链表建立主要有3个结构体变量，这
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值