Java数据结构-线性表的设计与实现(头歌平台，详细注释)

已于 2024-05-29 19:32:34 修改
阅读量1.4k 收藏 17
点赞数 10
分类专栏： java头歌平台 文章标签： 数据结构 java
于 2023-09-18 14:59:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwertf123/article/details/132978945
版权

目录

第1关：顺序表的实现之增删功能

任务描述

相关知识

顺序表

增加元素

删除元素

Java 数组

声明数组变量

创建数组

Java 中的数组下标

代码： 

第2关： 顺序表的实现之查询功能

任务描述

相关知识

代码：  

第3关：单链表的实现之增删功能

任务描述

相关知识

链表

链表的概念

单链表

向单链表中添加元素

从单链表中删除元素

Java静态内部类

代码：  

第4关：单链表的实现之查询功能

任务描述

相关知识

代码：  

第1关：顺序表的实现之增删功能

任务描述

本关任务：实现一个顺序表，并实现增加元素，删除元素功能。

相关知识
顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。

顺序表是将表中的结点依次存放在计算机内存中，一组地址连续的存储单元中。

下图是一个顺序表示意图：

增加元素

现要插入元素到顺序表中，若没有指定添加元素的位置，则元素直接添加到数组末尾，表元素个数加1。

如指定要插入到位置index，则下标为index及之后的元素都需相应的移动。

现假设表中已有元素15 23 46 16 57 10 64，要插入一个新元素48到位置3（即调用list.Add(3,48)方法），因这里下标为3的元素是16，则16及之后的元素都需移动。

表中元素的变化过程如下图:

删除元素

同样，假设现在表中已有元素15 23 46 16 57 10 64，现要删除下标为3的元素，即调用list.remove(3)方法，则表中元素的变化过程如下图：

Java 数组

数组，是由相同类型的元素的集合所组成的数据结构，分配一块连续的内存来存储。你可以声明一个数组变量，如 arr[10] 来代替直接声明 10 个独立变量 arr0，arr1，....，arr9。

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

Type[] arrVar;   // 方式一
Type arrVar[];  // 方式二

这两种声明数组的方式都是正确的。 例如，声明一个double型数组，我们可以这样写：

double[] myArr
或者
double myArr[]
创建数组

Java语言使用new操作符来创建数组，如下：

myArr = new Type[arrSize];

arrSize是数组的大小，所以这里我们创建了一个大小为arrSize的Type类型的数组，并把它赋值给myArr。

数组变量的声明、创建数组可以用一条语句完成，如下：

Type[] arrVar = new Type[arrSize];

Java 中的数组下标

在Java中，数组的下标是从0开始的。如一个有7个元素的数组，其下标范围是0，1，2，3，4，5，6。

我们实现的表中，下标仍然是从0开始，即list.get(0)返回的是第一个元素，list.get(n-1)返回的是第n个元素。

代码： 
package step1;

/**
 * Created by zengpeng on 2017/12/25.
 */
public class MyArrayList {
    private int[] elements;//元素
    private int size;//List中当前的元素个数

    public MyArrayList() {
        this(1);//List默认大小为1
    }

    /**
     * 按指定大小capacity构造List
     *
     * @param capacity List初始化时的大小
     */
    public MyArrayList(int capacity) {
        elements = new int[capacity];
        size = 0;
    }

    /**
     * 返回List中元素的个数
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 添加一个元素到末尾
     *
     * @param item
     */
    public void Add(int item) {
        int len = elements.length;
        if (size == len - 1) {
            resize(2 * len);
        }
        /********** Begin *********/
        //添加一个元素到末尾
        elements[size++] = item;//数组个数++，保存新元素
        /********** End *********/
    }

    /**
     * 添加一个元素到指定位置index
     *
     * @param index
     * @param item
     */
    public void Add(int index, int item) {
        validateRangeForAdd(index);
        int len = elements.length;
        if (size == len - 1) {
            resize(2 * len);
        }
        /********** Begin *********/

        //添加一个元素到指定位置index
        for (int i = size; i > index; i--) //寻找要插入的位置
        {
        elements[i] = elements[i - 1];//将要插入位置后的所有元素向后移动一位
        }
        elements[index] = item;//当前位置添加插入元素
        size++;//元素个数+1


        /********** End *********/
    }

    /**
     * 删除指定位置index的元素,并返回被删除的元素
     *
     * @param index
     * @return 被删除的元素
     */
    public int remove(int index) {
        validateRange(index);
        /********** Begin *********/

        //删除指定位置index的元素,并返回被删除的元素
        int oldVal = elements[index];//保存要删除元素
        for (int i = index; i < size - 1; i++) //寻找要删除的位置
        {
        elements[i] = elements[i + 1];//删除元素所有删除位置以后的元素向前移动一位
        }
        --size;//元素个数-1
        return oldVal;//返回要删除元素

        /********** End *********/
    }

    /**
     * 校验索引范围
     *
     * @param index
     */
    private void validateRange(int index) {
        if (index >= size || index < 0) {
            throw new ArrayIndexOutOfBoundsException("索引越界了哦！Index: " + index + ", Size: " + size);
        }
    }

    /**
     * 校验索引范围
     *
     * @param index
     */
    private void validateRangeForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException("索引越界了哦！Index: " + index + ", Size: " + size);
    }

    /**
     * 动态扩展数组大小
     *
     * @param capacity
     */
    private void resize(int capacity) {
        assert capacity > size;
        int[] tmp = new int[capacity];
        for (int i = 0; i < size; i++) {
            tmp[i] = elements[i];
        }
        elements = tmp;
    }
}

以下是测试样例：

  1. list.Add(0, 3);
  2. list.Add(5);
  3. list.Add(7);
  4. list.Add(-1);
  5. list.Add(2, 4);
  6. list.Add(-6);
  7. list.remove(0);
  8. while (list.size() > 0) {
  9. System.out.println(list.remove(0));
  10. }

预期输出

  1. 5
  2. 4
  3. 7
  4. -1
  5. -6

第2关： 顺序表的实现之查询功能

任务描述

在上一关，我们实现了表的基本功能：添加元素，删除元素。本关的任务是在上一关的基础上，实现获取指定位置元素的功能。

如list.get(2)返回表中下标为2的元素，即表中第3个元素。

相关知识

请参考上一关。

代码：  
package step2;

/**
 * Created by zengpeng on 2018/1/6.
 */
public class MyArrayList {
    private int[] elements;//元素
    private int size;//List中当前的元素个数

    public MyArrayList() {
        this(1);//List默认大小为1
    }

    /**
     * 按指定大小capacity构造List
     *
     * @param capacity List初始化时的大小
     */
    public MyArrayList(int capacity) {
        elements = new int[capacity];
        size = 0;
    }

    /**
     * 返回List中元素的个数
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 添加一个元素到末尾
     *
     * @param item
     */
    public void Add(int item) {
        int len = elements.length;
        if (size == len - 1) {
            resize(2 * len);
        }
        elements[size++] = item;
    }

    /**
     * 添加一个元素到指定位置index
     *
     * @param index
     * @param item
     */
    public void Add(int index, int item) {
        validateRangeForAdd(index);
        int len = elements.length;
        if (size == len - 1) {
            resize(2 * len);
        }
        for (int i = size; i > index; i--) {
            elements[i] = elements[i - 1];
        }
        elements[index] = item;
        size++;
    }

    /**
     * 删除指定位置index的元素,并返回被删除的元素
     *
     * @param index
     * @return 被删除的元素
     */
    public int remove(int index) {
        validateRange(index);
        int oldVal = elements[index];
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        --size;
        return oldVal;
    }

    /**
     * 返回表中下标为index的元素
     *
     * @param index 下标
     * @return
     */
    public int get(int index) {

        validateRange(index);
        /********** Begin *********/
        
        //返回表中下标为index的元素
        return elements[index];//直接返回该数组储存的元素

        /********** End *********/
    }

    /**
     * 校验索引范围
     *
     * @param index
     */
    private void validateRange(int index) {
        if (index >= size || index < 0) {
            throw new ArrayIndexOutOfBoundsException("索引越界了哦！Index: " + index + ", Size: " + size);
        }
    }

    /**
     * 校验索引范围
     *
     * @param index
     */
    private void validateRangeForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException("索引越界了哦！Index: " + index + ", Size: " + size);
    }

    /**
     * 动态扩展数组大小
     *
     * @param capacity
     */
    private void resize(int capacity) {
        assert capacity > size;
        int[] tmp = new int[capacity];
        for (int i = 0; i < size; i++) {
            tmp[i] = elements[i];
        }
        elements = tmp;
    }
}

以下是测试样例：

  1. list.Add(0, 3);
  2. list.Add(5);
  3. list.Add(7);
  4. list.Add(-1);
  5. list.Add(2, 4);
  6. list.Add(-6);
  7. list.remove(0);
  8. for (int i = 0; i < list.size(); i++) {
  9. System.out.println(list.get(i));
  10. }

第3关：单链表的实现之增删功能

任务描述

在之前的实训中，我们用数组实现了表，在本关我们将使用另外一种数据组织方式实现表。

我们注意到，在之前的关卡中为了防止数组溢出，我们在必要的时候对数组进行了扩展，但这样做的缺点是很明显的，每次扩展数组时都需要移动数据。而且在为新插入的元素腾出空间或者弥合删除后留下的间隙时，也要移动数据。而之所以要移动数据，是因为表是连续存储的，所以如果我们能保证表可以不连续存储，那么这种开销是可以避免的。

本关任务：实现一个带头结点的单链表，并实现基本功能：插入元素，删除元素。

相关知识
链表
链表的概念

链式方式实现的表，简称链表。链表是使用指针（即引用）将存储元素的那些单元依次串联在一起。这种方法避免了数组中用连续的单元存储元素的缺点，因而在插入或者删除时不再需要移动元素来腾出空间或填补空缺。

链表中元素之间的逻辑关系（前还是后）是通过设置指针（引用）表示的。因此每个单元至少有两个域，一个用于数据元素的存储，一个用于指向其他单元的指针。这种具有一个数据域和多个指针域的存储单元称为结点。(node)。

结点图示：

单链表

单链表的每个结点只有一个指向表中下一个结点的指针。我们称最后一个结点为尾结点，尾结点的特征是指针域(next)引用为空(null)。

单链表的一个图示如下：

下图是一个带头结点的单链表：

头结点中的数据域不存放数据，指针域指向链表的第一个结点，便于对链表操作。

向单链表中添加元素

插入数据示意图：

从单链表中删除元素

删除元素示意图：

Java是一门面向对象的语言，所以对于链表结点，我们需要定义一个类来表示，这里我们采用静态内部类的形式定义。

Java静态内部类

所谓内部类，就是在一个类内部定义的类。静态内部类是最简单的内部类形式，类定义时要加上static关键字，且不能和外部类有相同的名字。静态内部类会被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。生成静态内部类对象的方式为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();

静态内部类使用代码示例：

代码：  
package step3;

/**
 * Created by zengpeng on 2017/12/25.
 */
public class MyLinkedList {

    private Node first;//头结点，不存数据
    private Node last;//指向链表的最后一个节点
    private int size;

    public MyLinkedList() {
        size = 0;
        first = new Node(0, null);
        last = null;
    }

    /**
     * 添加到链表尾部
     *
     * @param item
     */
    public void add(int item) {
        /********** Begin *********/
        //添加到链表尾部
        Node x = last;//保存尾结点
        Node node = new Node(item, null);//创建新结点，并赋值元素
        last = node;//尾结点变为新结点
        if (first.next == null) //如果第一个结点(相当于头结点)指向空就表示没有元素
        {//首次添加
      first.next = node;//第一个结点指向新结点
        } 
        else 
        {
      x.next = node;//尾结点指向新结点
        }
        ++size;//元素个数+1


        /********** End *********/
    }

    /**
     * 添加数据item到指定位置index
     * index从0开始
     * @param index
     * @param item
     */
    public void add(int index, int item) {
        checkPosIndex(index);

        /********** Begin *********/

        //添加数据item到指定位置index
        Node x = first;//保存第一个结点
        while (index-- > 0) //个数减少，当为0时代表找到要添加的位置的前一个结点
        {
         x = x.next;//保存当前结点
        }
        Node node = new Node(item, null);//创建新结点，并赋值元素
        if (null == first.next) //头结点指向为空代表没有数
        {//首次添加
         last = node;//尾结点指向新结点
        }
        node.next = x.next;//新结点指向要添加位置的前一个结点的指向
        x.next = node;//将要添加位置的前一个结点的指向为新结点
        ++size;//保存元素个数

        /********** End *********/
    }

    /**
     * 删除指定位置index处的元素并返回, index从0开始
     * @param index
     * @return
     */
    public int remove(int index) {
        checkPosIndex(index);

        /********** Begin *********/

         //删除指定位置index处的元素并返回, index从0开始
        Node g = first;//保存第一个结点
        while (index-- > 0) //个数减少，当为0时代表找到要删除的位置的前一个结点
        {
         g = g.next;//保存当前结点
        }
        Node d = g.next;//保存需要删除的元素
        if (d == last)
        {//删除最后一个元素
         last = g;//则让最后一个结点变为要删除的位置的前一个结点
        }
        g.next = d.next;//让要删除的位置的前一个结点的指向要删除元素的下一个结点(即跳过要删除的元素直接指向下一个，即为删除操作)
        --size;//元素个数-1
        return d.item;//返回要删除元素  

        /********** End *********/
    }

    public int size() {
        return size;
    }

    private void checkPosIndex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
    }

    //结点内部类
    private static class Node {
        int item;
        Node next;

        Node(int item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
}

以下是测试样例：

  1. list.add(0,1);
  2. list.add(5);
  3. list.add(7);
  4. list.add(-1);
  5. list.add(0, 3);
  6. list.add(2, 4);
  7. list.add(-6);
  8. list.remove(6);
  9. list.add(33);
  10. while (list.size()>0){
  11. System.out.println(list.remove(0));
  12. }

预期输出:

  1. 3
  2. 1
  3. 4
  4. 5
  5. 7
  6. -1
  7. 33

第4关：单链表的实现之查询功能

任务描述

在上一关，我们实现了单链表的基本功能：添加元素，删除元素。链式实现的表无法实现随机存取，因此要获取指定位置的元素，只能从头结点开始遍历。 本关任务：在上一关的基础上继续完善单链表的功能，实现获取指定位置元素的功能。

相关知识

请参考上一关

代码：  
package step4;

/**
 * Created by zengpeng on 2017/12/25.
 */
public class MyLinkedList {

    private Node first;//头结点，不存数据
    private Node last;//指向链表的最后一个节点
    private int size;

    public MyLinkedList() {
        size = 0;
        first = new Node(0, null);
        last = null;
    }

    /**
     * 添加到链表尾部
     *
     * @param item
     */
    public void add(int item) {
        final Node l = last;
        final Node node = new Node(item, null);
        last = node;
        if (first.next == null) {//首次添加
            first.next = node;
        } else {
            l.next = node;
        }
        ++size;
    }

    /**
     * 添加数据item到指定位置index
     * index从0开始
     * @param index
     * @param item
     */
    public void add(int index, int item) {
        checkPosIndex(index);
        int n = index;
        Node l = first;
        while ((n--) > 0) {
            l = l.next;
        }

        final Node node = new Node(item, null);
        if (null == first.next) {//首次添加
            last = node;
        }
        node.next = l.next;
        l.next = node;
        ++size;
    }

    /**
     * 删除指定位置index处的元素并返回, index从0开始
     * @param index
     * @return
     */
    public int remove(int index) {
        checkPosIndex(index);
        Node f = first;
        while ((index--) > 0) {
            f = f.next;
        }
        Node del = f.next;
        if (del == last) {//删除最后一个元素
            last = f;
        }
        f.next = del.next;
        del.next = null;

        int oldVal = del.item;

        del = null;
        --size;
        return oldVal;
    }


    /**
     * 获取链表中第index个元素
     * @param index
     * @return
     */
    public int get(int index) {
        checkPosIndex(index);
        /********** Begin *********/
        //获取链表中第index个元素
        Node l=first;//保存第一个结点
        for(int i=0;i<=index;i++)//寻找要获取的元素的位置
        {
       l=l.next;//保存当前结点
        }
        return l.item;//返回要获取元素

        /********** End *********/
    }

    public int size() {
        return size;
    }

    private void checkPosIndex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
    }

    //结点内部类
    private static class Node {
        int item;
        Node next;

        Node(int item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
}

以下是测试样例：

  1. list.add(0,1);
  2. list.add(5);
  3. list.add(7);
  4. list.add(-1);
  5. list.add(0, 3);
  6. list.add(2, 4);
  7. list.add(-6);
  8. list.remove(6);
  9. list.add(33);
  10. for (int i = 0; i < list.size(); i++) {
  11. System.out.println(list.get(i));
  12. }

预期输出

  1. 3
  2. 1
  3. 4
  4. 5
  5. 7
  6. -1
  7. 33

关于结点指向null，释放结点内存的操作这里可以不用，除非需要控制内存

星与星熙.
关注
  • 10
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
【java数据结构】线性表(顺序表及链表)及其实现
DempseyLee的博客
03-12 1713
01 引入： 多项式的表示 方法一：顺序结构直接表示（数组） 方法二：顺序存储结构存储非零项 方法三： 链表结构存储非零项 02 什么是线性表 线性表”：由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称为表头，表结束位置称表尾 说明：线性表也就是数组的一种特殊储存方式：从头到尾依次储存数据。 2.1 线性表抽象数据类型概述 线性表操作接口描述 public...
52.【Java 数据结构——线性表】
qq_69683957的博客
09-09 3226
增删改查
【数据结构】——线性表 (顺序存储和基于Java的运算实现)
最新发布
2301_82242670的博客
04-10 230
无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！，可以扫码获取！！（备注Java获取）**无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。
线性表的设计与实现
ay1368287814的博客
08-03 1346
一.线性表定义 1.线性表（List）是零个或多个数据元素的集合 2.线性表中的数据元素之间是有顺序的 3.线性表的数据元素个数是有限的 4.线性表中的数据元素的类型必须相同 二.数字定义 线性表是具有相同类型的n(>=0)个数据元素的有限序列（a1,a2,...an） ai是表项，n是表长度。 三.性质 a0为线性表的第一个元素，只有一个后继 an为线性表的最后一个元素，只有
java实现单链表的创建以及增删改查功能
2301_78058031的博客
01-21 706
数据结构，完成单链表的创建以及增删改查操作
数据结构(Java版)-线性表的实现与应用完整版.doc
10-01
"数据结构(Java版)-线性表的实现与应用完整版" 本文旨在通过Java实现线性表的基本操作，并应用于实际问题中。线性表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。本文将通过两个部分来介绍线性表的...
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构实验1--线性表的操作与实现.doc
06-15
数据结构实验1--线性表的操作与实现 本实验的主要目的是为了熟练掌握线性表在顺序存储和链式存储结构下的基本操作和简单应用。通过实验，我们可以学习如何设计顺序表和链表，实现基本操作如创建、查找、插入、删除...
数据结构与算法分析--线性表实现
04-01
线性表的实现：插入，删除等操作
java实现线性表
12-19
压缩包中有两个.java文件，一个是接口一个是具体实现，使用java代码实现了线性表
数据结构（1）线性结构——数组、链表、堆栈、队列（介绍和JAVA代码实现）
Joker_ZJN的博客
11-10 1233
详细介绍、数组、链表、堆栈、队列，包含JAVA版代码实现
数据库实验报告八（头歌）
Coisioi的博客
11-29 1320
文章仅供学习参考
JAVA基础-数据结构一（线性表、链表、栈、队列）
2302_76949164的博客
03-10 945
/定义一个泛型数组//数组内元素的实际数量//size代表数组里实际有效的数据数量java里面没有像C语言的结构体，但java有内部类新建一个内部类Node表示链表内的单个节点，内部类中包括1.元素2.指向下一节点的指针3.构造函数给元素赋值构造好节点类，再新建头结点和尾结点指针，并新建size表示链表的有效长度{//定义一个结点内部类E data;Node next;//指向下一结点的指针//头结点//尾结点//链表实际长度。
Java数据结构-循环链表的设计与实现(头歌平台，详细注释)
qwertf123的博客
09-25 1496
Java数据结构-循环链表的设计与实现
【Java数据结构】线性表
m0_51692337的博客
01-03 361
线性表我认为就是数组。。。 创建： private int[] elements;//元素 private int size;//List中当前的元素个数 public MyArrayList() { this(1);//List默认大小为1 } /** * 按指定大小capacity构造List * * @param capacity List初始化时的大小 */ public MyArrayList(in
数据结构与算法 —— Java 实现（线性表）
欢迎来到Gorit的博客
03-20 2332
数据结构与算法 （Java 语言实现） —— 线性表一、Java 数组的回顾学习二、使用 OOP 编写变长数组2.0 准备2.1 实现 add 动态添加一个元素2.2 实现 delete 删除任意一个位置的元素2.3 实现 size 方法获取当前数组的长度2.4 实现 get 获取指定下标的元素2.5 实现 insert 在任意位置插入一个元素2.6 实现 set 替换任意一个元素 一、Java ...
Java数据结构——线性表
m0_51274044的博客
11-28 1347
线性表的顺序表示和实现 线性表的顺序表示形式： 用一组地址连续的存储单元依次存储线性表中的数据元素 在接口中定义方法： package qianyu.ch02; public interface MyArrayList { //定义一些方法 //查询线性表中数据元素个数 int getSize(); //判断线性表是否为空 boolean isEmpty(); //在线性表指定索引位置处插入元素 void insert(int i,Object e); //判断线性表中是否存在元素.
java线性表_Java数据结构之线性表
weixin_35816805的博客
02-12 185
线性表是其组成元素间具有线性关系的一种数据结构，对线性表的基本操作主要有，获取元素，设置元素值，遍历，插入，删除，查找，替换，排序等。而线性表可以采用顺序储存结构和链式储存结构，本节主要讲解顺序表、单链表以及双链表的各种基本操作。1：线性表抽象的数据类型线性表：是由n(n>=0)个数据相同的元素组成的有限序列。线性表的定义接口如下public interface IList {/*** 是否...
头歌java数据结构-线性表的设计与实现
09-29
在Java中，我们还可以利用已有的数据结构类库来简化线性表的设计和实现。例如，Java提供了ArrayList和LinkedList两个类，分别基于数组和链表实现了线性表的功能，并提供了丰富的方法来操作线性表。我们可以直接使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

星与星熙.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值