数据结构与算法之单向链表的设计与实现

已于 2022-12-19 15:17:45 修改
阅读量451 收藏 4
点赞数 5
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
于 2022-01-01 22:35:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49692893/article/details/122271784
版权

文章目录

前言

动态数组有个明显的缺点：可能会造成内存空间的大量浪费。能否设计一种数据结构以达到用到多少就申请多少内存？链表可以办到这一点。

一、基础概念

1.1 线性表的类型

线性表是一种逻辑结构，这种逻辑结构在计算机的表现形式(存储结构)主要有两种：
1.线性存储：用顺序存储结构的线性表也叫做顺序表，一般用数组实现。
2.链式存储：用链式结构存储的线性表也叫做链表，链表由一个个节点组成节点由数据域和指针域组成。

1.2 链表定义

链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的，如下图所示：
在这里插入图片描述

1.3 ArrayList和LinkedList谁更占空间？

一般情况下，LinkedList的占用空间更大，因为每个节点要维护指向前后地址的两个节点，但也不是绝对如果刚好数据量超过ArrayList默认的临时值时，ArrayList占用的空间也是不小的，因为扩容的原因会浪费将近原来数组一半的容量不过因为ArrayList的数组变量是用transient关键字修饰的，如果集合本身需要做序列化操作的话，ArrayList这部分多余的空间不会被序列化。

1.4 链表的优缺点

  • 优点：
    1.元素的存储单元是任意的可以连续也可以不连续，插入删除效率高只需要改变引用即可。
    2.没有空间限制存储的元素只要内存够大可以无上限存储。
    3.动态分配内存空间，不用事先开辟较为灵活，空间利用率高。
  • 缺点：
    1.查找效率低，涉及到从链表的头遍历到查询数据元素的位置。

二、接口设计

2.1 接口类图

在这里插入图片描述

2.2 清空元素-clear

在这里插入图片描述
frist = null 就已经指明链表元素没有被引用，会被gc回收。

@Override
public void clear() {
    size = 0;
    first = null;
}

2.3 新增元素-add

在这里插入图片描述

@Override
public void add(int index, E element) {
    /*
     * 最好：O(1)
     * 最坏：O(n)
     * 平均：O(n)
     */
    rangeCheckForAdd(index);
    // 给空链表添加第一个元素的情况
    if(index == 0){
        first = new Node<>(element, first);
    }else{
        Node<E> prev = node(index - 1);
        prev.next = new Node<>(element, prev.next);
    }
    size++;
}

2.4 获取元素–get

@Override
public E get(int index) {
	return node(index).element;
}

//获取index位置的节点
private Node<E> node(int index) {
    rangeCheck(index);
    Node<E> node = first;
    for (int i = 0; i < index; i++) {
        node = node.next;
    }
    return node;
}

2.5 设置元素-set

@Override
public E set(int index, E element) {
    /*
     * 最好:O(1)
     * 最坏:O(n)
     * 平均:O(n)
     */
    E old = node(index).element;
    node(index).element = element;
    return old;
}

2.6 删除元素–remove

@Override
public E remove(int index) {
    /*
     * 最好：O(1)
     * 最坏：O(n)
     * 平均：O(n)
     */
    rangeCheck(index);
    Node<E> node = first;
    if (index == 0) { // 删除第一个元素是特殊情况
        first = first.next;
    } else {
        Node<E> prev = node(index - 1); // 找到前一个元素
        node = prev.next; // 要删除的元素
        prev.next = node.next; // 删除元素
    }
    size--;
    return node.element;
}

2.7 复杂度分析

在这里插入图片描述

2.8 代码实现

公用List接口封装：

public interface List<E> {

    static final int ELEMENT_NOT_FOUND = -1;
    /**
     * 清除所有元素
     */
    void clear();

    /**
     * 元素的数量
     * @return
     */
    int size();

    /**
     * 是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    boolean contains(E element);

    /**
     * 添加元素到尾部
     * @param element
     */
    void add(E element);

    /**
     * 获取index位置的元素
     * @param index
     * @return
     */
    E get(int index);

    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return 原来的元素ֵ
     */
    E set(int index, E element);

    /**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    void add(int index, E element);

    /**
     * 删除index位置的元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    int indexOf(E element);
}

抽象类AbstractList：

public abstract class AbstractList<E> implements List<E>{

    public int size;

    /**
     *获取集合中的数据元素的个数
     */
    @Override
    public int size(){
        return size;
    }

    /**
     *判断集合是否为空(无数据元素)
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     *获取集合中数据元素是否包含element参数
     */
    @Override
    public boolean contains(E element){
        return false;
    }

    /**
     *向集合中添加数据元素
     */
    @Override
    public void add(E element){
       /*
        * elements[size] = element;
        * size++;
        */
        add(size, element);
    }

    public void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:" + index+ ",Size:" +size);
    }

    public void rangeCheck(int index){
        if (index < 0 || index >= size){
            outOfBounds(index);
        }
    }

    public void rangeCheckForAdd(int index){
        if (index < 0 || index > size){
            outOfBounds(index);
        }
    }

}

实现类LinkedList：

public class LinkedList<E> extends AbstractList<E>{

    private Node<E> first;

    // 链表中的节点
    private static class Node<E> {
        E element; // 节点元素
        Node<E> next; // 节点指向下一个节点

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }

    @Override
    public void clear() {
        size = 0;
        first = null;
    }

    @Override
    public E get(int index) {
        return node(index).element;
    }
    /**
     * 根据索引找到节点
     */
    private Node<E> node(int index) {
        rangeCheck(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    @Override
    public E set(int index, E element) {
        /*
         * 最好:O(1)
         * 最坏:O(n)
         * 平均:O(n)
         */
        E old = node(index).element;
        node(index).element = element;
        return old;
    }

    @Override
    public void add(int index, E element) {
        /*
         * 最好：O(1)
         * 最坏：O(n)
         * 平均：O(n)
         */
        rangeCheckForAdd(index);
        // 给空链表添加第一个元素的情况
        if(index == 0){
            first = new Node<>(element, first);
        }else{
            Node<E> prev = node(index - 1);
            prev.next = new Node<>(element, prev.next);
        }
        size++;
    }

    @Override
    public E remove(int index) {
        /*
         * 最好：O(1)
         * 最坏：O(n)
         * 平均：O(n)
         */
        rangeCheck(index);
        Node<E> node = first;
        if (index == 0) { // 删除第一个元素是特殊情况
            first = first.next;
        } else {
            Node<E> prev = node(index - 1); // 找到前一个元素
            node = prev.next; // 要删除的元素
            prev.next = node.next; // 删除元素
        }
        size--;
        return node.element;
    }

    @Override
    public int indexOf(E element) {
        // 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
        // 因此需要对元素是否为null做分别处理
        if (element == null) {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        } else {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (node.element.equals(element)) return i;
                node = node.next;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("[size=").append(size).append(", ");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        return string.toString();
    }

}

测试类LinkedListTest ：

public class LinkedListTest {
    public static void main(String[] args) {
       List<Integer> list = new LinkedList<>();
       list.add(10);
       list.add(20);
       list.add(30);
       list.add(list.size(),40);
       list.remove(1);
        System.out.println(list);
    }
}

运行结果：
在这里插入图片描述

南波塞文
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性链表/单链表设计
m0_70184760的博客
05-13 1186
在设计单链表时，我们首先要引入单链表的定义，你首先得知道它是什么？ 结点：用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的），对其中一个数据元素来说，不仅要存储其本身的信息之外没还需存储一个指示其直接后继的信息（即直接后继的存储位置），这两部分信息组成这个数据元素的存储映像，称为结点。 线性链表/单链表：结点包括两个域，存储数据元素信息的被称为数据域，存储其直接后继存储位置的域称为指针域，指针域中存储的信息称作指针/链。多个结点链接成一个链表，即为线性表的链式存储结构，.
设计单向链表
aiyafu1371的博客
06-02 176
设计单向链表 标签： C++ 以重复造轮子为目的设计一个单向链表。 链表单元 class CList { public: CList() { pPre = NULL; }; ~CList(); CList* pPre; } 链表生成 CList* pLast = NULL; while(1) { CList *pCurre...
单向链表的设计
爱编程的小芯
08-16 452
何为单向链表 链表是一种数据结构，你可以把它想象成一种动态的数组，此数组大小不固定，可以在需要时动态增加、删除元素。它解决了使用数组时大小固定不可更改的痛点。 如上图所示，单向链表主要由一个一个节点组成。每个节点包含一个值 Value 和一个指针 * next ，值 Value 用于存储链表中的数值，指针 * next 用于指向下一个节点。 定义一个指针 * Head 用于指向链表头节点。 头节点的作用：表示单向链表的头部（不存放具体数据）。 设定最后一个节点的 * next 的地址为 NULL ，表示链
数据结构与算法：链表的基本设计思路
weixin_50690285的博客
06-01 358
数据结构与算法：调整链表元素的基本思路
设计单向链表的实现
gaoster的博客
04-08 200
public class ListNode{//设计单向链表的实现 int val; ListNode next; ListNode(int x){ val = x; } } class MyLinkedList { int size; ListNode head; /** Initialize your data stru...
单链表的设计
Pxx520Tangtian的博客
12-13 381
先来写一个头文件：linklist.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ //数据节点 typedef struct _link_list_node link_list_node; struct _link_list_node { link_list_node *next; int value; }; link_list_node* create(); int get_len(link_list_node *
链表数据结构
读心悦
05-10 509
链表 一种动态的数据结构，会按需扩容。 链表存储有序的元素集合，链表的元素在内存中不是连续存放的，每一个元素是由元素本身节点和指向下一个元素的引用（指针或者是链接）构成。 在访问链表的时候，需要从起点开始迭代链表，直到找到指定元素位置 双向链表 每个元素都有指向下一个和上一个元素的链， 循环链表 结构包含了链表和双向链表 循环链表和链表之间的区别在于，最后一个元素指向下一个元素的指针【tail.next】不是undefined，而是指向第一个元素【head】 /* * @FileName: 链表 * .
链表数据结构实现
SILENCE_LM_的博客
05-05 800
链表的定义与使用链表的基本概念链表开发入门（实现的基本原理） 链表的基本概念 链表=可变长的对象数组，属于动态对象数组范畴。 对象数组有哪些问题呢？ 正因为如此现在如果要想让其可以编写出便于维护的代码，那么就需要实现一个动态对象数组，就可以使用链表完成。 但是现在如果想要实现动态的对象数组，要考虑两个问题： 为了适应所有的开发要求，此对象数组要求可以保存所有的数据类型，那么一定首选Object...
单向链表及其两种实现
Happig的博客
11-28 596
简介 链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。 一、指针实现 创建链表使用malloc()函数分配内存空间，之后的指针操作可以直接改变链表的连接结构 链表的索引...
数据结构--链表的思想和实现代码
weixin_30725467的博客
04-16 97
链表是一种最常用的数据结构，其他的数据结构也可以由链表实现，链表由一系列不必在内存中相连的结构组成，每一个结构均含有表元素和指向该元素后继元的结构的指针，称为Next指针，为了方便理解，我们把这样的结构称为节点，最后一个节点的Next指针指向NULL，有的情况下，还为链表添加一个头节点，可以防止在删除链表的第一个元素时，丢失链表，如下图所示： 对链表的操作通常是创建一个链表，...
数据结构和算法（一）设计链表
qq_28258861的博客
07-19 421
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 ...
数据结构链表实现
weixin_44146131的博客
01-05 509
数据结构链表的实现第一部分：实验分析与设计一、实验内容描述二、实验基本原理与设计三、主要仪器设备及耗材四、附录 第一部分：实验分析与设计 一、实验内容描述 利用Linux GNU make C 项目管理软件工具实现数据结构链表(Linked List)。要求实现以下功能：Push, Pop, Insert, Delete, Search, Visit go through, Clear。节点的数据...
数据结构算法链表篇之设计链表
最新发布
weixin_43369836的博客
09-18 238
完善得到链表中相对应索引的值、在链表头部添加节点、在链表尾部添加节点、在给定索引值的元素前面添加节点、删除给定索引的节点的API
链表的设计
qq_43666632的博客
09-09 741
链表的设计与实现
链表设计
free-go的博客
02-11 281
package dynamic; /** * @Author free-go * @Date Created in 19:18 2020/2/11 **/ class MyLinkedList { ListNode head; ListNode last; int total; class ListNode { //成员内部类 ...
无头单链表—简单功能的实现
weixin_45636889的博客
12-10 144
单链表的头文件如下： #include "Slist.h" void SlistPrint(SlistNode* plist){ SlistNode* cur = plist; while (cur != NULL){ printf("%d->", cur->data); cur = cur->next; } printf("NULL\n"); } SlistN...
链表
coffee0218的博客
04-05 1049
一.单链表 707.设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第index个...
数据结构：线性链表
GaodadaMaster的博客
08-22 300
视频看再多不如自己亲手敲一遍！！！ 内容：数据结构第二章线性链表C语言代码实现 参考书：数据结构严书，高一凡数据结构与算法 测试软件：Visual Studio 2017 坚持天数：3 c1.h： #ifndef __C1_H //#define __C1_H //c1.h(头文件名) #include <string.h> //字符串函数头文件 #include <c...
数据结构之线性结构-链表
weixin_44037272的博客
06-27 506
文章目录链表单链表双链表循环链表 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的
数据结构课程设计：约瑟夫环与单向循环链表实现
在这个课程设计中，学生们的目标是通过实现一个完整的程序来深入理解和应用数据结构，特别是单向循环链表。该设计旨在配合《数据结构》课程的学习，让学生掌握算法编写、类C语言编程技巧以及如何将算法转化为实际的C...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值