数据结构—线性表(LinearList)的原理以及Java实现案例

最新推荐文章于 2022-04-11 23:19:02 发布
最新推荐文章于 2022-04-11 23:19:02 发布
阅读量3k 收藏 9
点赞数 3
分类专栏： Java 数据结构与算法 文章标签： java 数据结构 算法 链表 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43767015/article/details/105647541
版权

详细介绍了Java线性表中基于的数组、链表的实现逻辑，并附有数组线性表、单链表、静态链表的Java实现案例。

文章目录


线性表：零个或多个数据元素的有限序列。包括数组、链表、栈空间、队列等结构都属于线性表。

最基本的线性表描述为：线性表的数据对象集合为{a1,a2, …,an}，除了最后一个元素an外，每一个元素有且只有一个直接后继元素数据，元素之间的关系是一对一的关系。随之数据结构的发展，后续还出现了更加复杂的线性表，它们可能会有其它特性，但是对于上面的基本特性都是遵守的。

上面的线性表是指的一种逻辑数据结构，而对于这种逻辑结构的实现，即物理结构，采用顺序储存结构和线性储存结构都能实现。关于顺序储存结构和线性储存结构以及数据结构的入门，可以看这篇博客：数据结构入门以及分类介绍。

1 线性表的顺序存储结构

1.1 线性表顺序存储结构概述

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

线性表（a1,a2,…,an）的顺序存储示意图如下：

在这里插入图片描述

我们可以采用数组来实现线性表的顺序存储结构。把第一个数据元素存到数组下标为0的位置中，这个位置称为索引，接着把线性表相邻的元素存储在数组中相邻的位置。

数组的长度是存放线性表的存储空间的长度，存储分配后这个量一般是不变的。所谓的扩展一般是指新建一个更大的数组，并将原数组的元素复制到新数组中。

线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的。

用数组存储顺序表意味着要分配固定长度的数组空间，由于线性表中可以进行插入和删除操作，因此分配的数组空间要大于等于当前线性表的长度。

1.2 线性表顺序存储结构的查找

存储器中的每个存储单元都有自己的编号，这个编号称为地址。由于数组的储存单元是连续的，并且每一个数组元素的空间是一样大的，因此我们可以以随时算出线性表中任意位置的地址，不管它是第一个还是最后一个，都是相同的时间。

那么我们对每个线性表位置的存入或者取出数据，对于计算机来说都是相等的时间，也就是一个常数，因此用我们算法中学到的时间复杂度的概念来说，它的存取时间性能为O(1)。我们通常把具有这一特点的存储结构称为随机存取结构。

1.3 线性表顺序存储结构的增删

基于数组的线性表的查找非常快，但是如果想在任意位置上添加或者删除数据，那么就很慢了。

  1. 向数组中i索引位置添加新数据时：
    1. 首先判断如果插入位置不合理，抛出异常；
    2. 如果插入后线性表长度大于等于数组长度，则抛出异常或动态增加容量；
    3. 遍历i索引处的后面的所有元素，分别将它们都向后移动一个位置；
    4. 将要插入元素填入索引i处，表长加1。
  2. 向数组中i索引位置删除新数据时：
    1. 如果删除位置不合理，抛出异常；
    2. 取出删除元素；
    3. 遍历i索引处的后面的所有元素，分别将它们都向前移动一个位置；
    4. 将原末位元素的值置为null；
    5. 表长减1。

从上面的步骤可以看出来，必须把目标位置后面的数据一个个前移或者后移，元素个数为n。

最好的情况，如果元素要插入到最后一个位置，或者删除最后一个元素，此时时间复杂度为O(1)，因为不需要移动元素的。

最坏的情况，如果在数组头部添加或者删除元素，那就意味着要向后或者向前移动所有的元素，所以这个时间复杂度为O(n)。

平均的情况，最终平均移动次数和操作最中间的那个元素的移动次数相等，为(n-1)/2。

因此数组的添加、删除元素的时间复杂度为O(n)。

1.4 线性表顺序存储结构的优缺点

在这里插入图片描述

1.5 线性表顺序存储结构的简单实现

/**
 * 线性表的顺序储存结构的简单数组实现,为了演示方便,设计为不可扩展。
 */
public class MyFinalArrayList<E> {

    /**
     * 底层使用数组来存储数据
     */
    private final Object[] elements;

    /**
     * 当前存储的元素个数
     */
    private int size;


    /**
     * 总容量,数组长度
     */
    private final int capcity;

    /**
     * 构造器中初始化数组
     *
     * @param capcity
     */
    public MyFinalArrayList(int capcity) {
        this.capcity = capcity;
        elements = new Object[capcity];
    }

    /**
     * 新增一个元素,默认加在线性表末位
     *
     * @param element 添加的元素
     * @return 添加成功返回true，添加失败返回false
     */
    public boolean add(E element) {
        //线性表是否容量已满
        if (size == capcity) {
            // 添加失败返回false
            return false;
        }
        //添加元素到size索引，并且size自增1
        elements[size++] = element;
        //返回true，添加成功
        return true;
    }


    /**
     * 删除一个元素,默认删除线性表的首位
     *
     * @return 返回被删除的元素或者返回null
     */
    public E delete() {
        //如果链表为空,则返回空
        if (size == 0) {
            return null;
        }
        //需要移动的元素的数量
        int length = size - 1;
        //将要被删除的元素
        Object e = elements[0];
        //移动后续的全部元素
        System.arraycopy(elements, 1, elements, 0, length);
        //原最后一个元素的位置置空
        elements[--size] = null;
        return (E) e;
    }

    /**
     * 删除首个与输入元素相同的元素
     */
    public boolean delete(Object element) {
        if (size > 0) {
            for (int index = 0; index < size; index++) {
                if (element == null) {
                    if (elements[index] == null) {
                        int numMoved = size - index - 1;
                        System.arraycopy(elements, index + 1, elements, index, numMoved);
                        elements[--size] = null;
                        return true;
                    }
                } else {
                    if (element.equals(elements[index])) {
                        int numMoved = size - index - 1;
                        System.arraycopy(elements, index + 1, elements, index, numMoved);
                        elements[--size] = null;
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 根据索引删除某个索引处的元素
     */
    public E delete(int index) {
        rangeCheck(index);
        E e = (E) elements[index];
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elements, index + 1, elements, index, numMoved);
        }
        elements[--size] = null;
        return e;
    }

    /**
     * 更新某个索引的元素值
     */
    public void set(int index, Object newElement) {
        rangeCheck(index);
        elements[index] = newElement;
    }

    /**
     * 是否包含某个元素
     *
     * @param element 元素
     * @return false 不包含 true 包含
     */
    public boolean contains(Object element) {
        if (size > 0) {
            for (int index = 0; index < size; index++) {
                if (element == null) {
                    if (elements[index] == null) {
                        return true;
                    }
                } else {
                    if (element.equals(elements[index])) {
                        return true;
                    }
                }
            }
        }
        return false;
    }


    /**
     * 获取指定索引的元素
     *
     * @param index 指定索引
     * @return 指定索引的元素
     */
    public E get(int index) {
        //检查索引越界
        rangeCheck(index);
        return (E) elements[index];
    }

    /**
     * 返回第一个元素
     *
     * @return 第一个元素, 或者null 没有元素
     */
    public E get() {
        if (size > 0) {
            return (E) elements[0];
        }
        return null;
    }

    /**
     * 返回指定元素出现的的首个位置索引
     *
     * @param element 制定元素
     * @return 返回索引, 或者-1,未找到该元素
     */
    public int indexOf(Object element) {
        if (size > 0) {
            for (int index = 0; index < size; index++) {
                if (element == null) {
                    if (elements[index] == null) {
                        return index;
                    }
                } else {
                    //默认通过equals比较元素是否相等
                    if (element.equals(elements[index])) {
                        return index;
                    }
                }
            }
        }
        //未找到元素,返回-1
        return -1;
    }


    /**
     * 返回线性表元素数量
     *
     * @return 线性表元素数量
     */
    public int size() {
        return size;
    }

    /**
     * 重写了toString方法
     *
     * @return
     */
    @Override
    public String toString() {
        if (size == 0) {
            return "[ ]";
        }
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[ ");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elements[i]);
            if (i != size - 1) {
                stringBuilder.append(", ");
            }
        }
        stringBuilder.append(" ]");
        return stringBuilder.toString();
    }

    /**
     * 检查索引
     */
    private void rangeCheck(int index) {
        if (index >= size) {
            //throw抛出异常
            throw new IndexOutOfBoundsException("索引越界:" + index);
        }
    }
}

1.5.1 测试

System.out.println("初始化线性表,容量为6===============>");
MyFinalArrayList<Object> objectMyFinalList = new MyFinalArrayList<>(6);
System.out.println("插入元素===============>");
objectMyFinalList.add(null);
objectMyFinalList.add(2);
objectMyFinalList.add("3");
objectMyFinalList.add("3");
objectMyFinalList.add(null);
objectMyFinalList.add("3");
//尝试添加第七个元素,不会添加成功
objectMyFinalList.add("6");
//输出内部的元素
System.out.println(objectMyFinalList);
System.out.println("获取第一个元素===============>");
//获取第一个元素
Object o = objectMyFinalList.get();
System.out.println(o);
System.out.println("获取size===============>");
//获取size
int size1 = objectMyFinalList.size();
System.out.println(size1);
System.out.println("删除第一个为null的元素===============>");
boolean delete = objectMyFinalList.delete(null);
System.out.println(delete);
System.out.println("再次获取size===============>");
int size2 = objectMyFinalList.size();
System.out.println(size2);
System.out.println("删除指定索引元素===============>");
Object delete1 = objectMyFinalList.delete(1);
//索引越界
//objectMyFinalList.delete(7);
System.out.println(delete1);
System.out.println("再次获取size===============>");
int size3 = objectMyFinalList.size();
System.out.println(size3);
System.out.println("设置指定索引的元素值===============>");
objectMyFinalList.set(0, "设置值1");
System.out.println("获取该索引的元素值验证===============>");
Object o2 = objectMyFinalList.get();
System.out.println(o2);
System.out.println("获取指定值所在的第一个索引===============>");
int index = objectMyFinalList.indexOf("3");
System.out.println(index);
System.out.println("输出全部元素===============>");
System.out.println(objectMyFinalList);
System.out.println("再次获取size===============>");
int size4 = objectMyFinalList.size();
System.out.println(size4);
System.out.println("是否包含===============>");
System.out.println(objectMyFinalList.contains(null));

2 线性表的链式存储结构

2.1 线性表链式存储结构概述

由于顺序存储结构元素相邻的特性，中间不能有空闲的内存空间。因此在插入和删除时为了保证元素相邻，就会涉及到大量元素的移动，这显然就需要耗费时间。
因此为了降低增删元素的时间复杂度，我们可以考虑链式存储结构。

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元在内存空间中可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。

但是为了保证不连续空间中的元素能够找到它们的前驱和后继，在链式结构元素的构成中，除了要存数据元素信息外，还要存储它的后继或者前驱元素的存储地址。

我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称做指针或链。这两部分信息组成数据元素的存储映像，称为结点。

n个结点链结成一个线性表，也称为链表。

如果链表的每个结点中只包含一个指针域，所以叫做单链表。单链表正是通过每个结点的指针域将线性表的数据元素按其逻辑次序链接在一起。

链表很好的解决了数组增、删元素的不足，因为当要在某个位置增删元素是，只需要修改相邻元素的指针指向新增加的元素就行了，不需要移动元素的位置。

2.2 单链表

下面先介绍最简单的单链表的操作。

2.2.1 单链表的查找

在线性表的顺序存储结构中，我们要计算任意一个元素的存储位置是很容易的。但在单链表中，因为数据都是分散存储的，所以如果想要访问数据，只能从第1个数据开始，顺着指针的指向一一往下访问（这便是顺序访问）。因此，对于单链表实现获取第i个元素的数据的操作，在算法上，相对要麻烦一些。

获得链表第i个索引数据的算法思路：

  1. 先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。
  2. 然后声明一个变量f指向链表第一个结点，在循环中初始化j从0开始；
  3. 当j<i时，就遍历链表，让的指针向后移动，不断指向下一结点，即f=f.next，同时j自增1；
  4. 当循环结束，变量f指向的就是我们要找的第i个索引的数据。

说白了，就是从头开始找，直到第i+1个结点为止。我们把链表中的数据量记成n，由于这个算法的时间复杂度取决于i的位置，当i=0时，则不需遍历，第一个就取出数据了，而当i=n时则遍历n-1次才可以。因此最坏情况的时间复杂度是O(n)。这样的查找也称为（线性查找）。

2.2.2 单链表的增删

  1. 在指定索引i处插入数据
    1. 先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。
    2. 然后通过查找，找到原索引i的元素x，以及原索引i的前驱元素y。
    3. 构建一个新的节点z，新节点的后继元素指向原索引元素z.next=x
    4. 原索引i的前驱元素y的后继指向新的元素，y.next=z
  2. 在指定索引i处删除数据
    1. 先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。
    2. 然后通过查找，找到原索引i的元素x，以及原索引i的前驱元素y，以及原索引i的后继元素z。
    3. 让y的next指向z，y.next=z
    4. 回收x

分析一下上面的单链表插入和删除算法，我们发现，它们其实都是由两部分组成：第一部分就是遍历查找i索引结点；第二部分就是插入和删除结点。

我们把链表中的数据量记成n，插入和删除数据只需要更改两个指针的指向，所以耗费的时间与n 无关。如果已经到达了添加数据的位置，那么添加操作只需花费O(1) 的时间。删除数据同样也只需O(1) 的时间。

虽然需要前期的查找时间，但是我们假设需要在索引i出插入10个元素，那么对于顺序存储结构意味着，每一次插入都需要移动n-i-1个结点，时间复杂度每次都是O(n)。而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，针对插入和删除这两个操作，链表的时间复杂度都是O(1)。显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。

2.2.3 单链表的简单实现

/**
 * 线性表的链式储存结构的简单 单链表实现
 */
public class MySingleLinkedList<E> {

    /**
     * 空构造器,内部的节点均没有初始化,在第一次添加时才会初始化。
     */
    public MySingleLinkedList() {
    }

    /**
     * 元素个数
     */
    private int size;

    /**
     * 指向头结点的引用
     */
    private Node<E> first;

    /**
     * 单链表内部的节点
     */
    private static class Node<E> {
        //下一个结点的引用
        Node<E> next;
        //结点数据
        E data;

        //节点构造器
        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }

    /**
     * 默认 添加元素到单链表尾部
     */
    public void add(E e) {
        //创建新节点
        Node<E> newNode = new Node<>(e, null);
        //如果头结点不为空
        if (first != null) {
            /*寻找尾节点*/
            Node f = first;
            while (f.next != null) {
                f = f.next;
            }
            f.next = newNode;
        } else {
            //如果头结点为空,那么新节点就是第一个节点,就是头结点。
            first = newNode;
        }
        size++;
    }

    /**
     * 默认 删除单链表头部元素
     */
    public E remove() {
        if (first == null) {
            throw new NoSuchElementException();
        }
        //如果头结点不为空
        E e = first.data;
        first = first.next;
        size--;
        return e;
    }


    /**
     * 添加元素到单链表指定索引位置，原索引节点链接为next
     */
    public void add(E e, int index) {
        checkPositionIndex(index);
        //如果index等于0
        if (index == 0) {
            first = new Node<>(e, first);
            size++;
            return;
        }
        //如果index等于1
        if (index == 1) {
            first.next = new Node<>(e, first.next);
            size++;
            return;
        }
        if (index == size) {
            add(e);
            return;
        }
        //暂时是头结点,循环结束后指向index索引节点
        Node<E> x = first;
        //index索引的前一个节点
        Node<E> y = null;
        for (int i = 0; i < index; i++) {
            x = x.next;
            if (i == index - 2) {
                y = x;
            }
        }
        //原index索引的前驱节点的next指向新节点,新节点的next节点指向原index索引节点
        y.next = new Node<>(e, x);
        size++;
    }


    /**
     * 删除单链表指定索引位置的元素
     */
    public E remove(int index) {
        checkElementIndex(index);
        if (index == 0) {
            return remove();
        }
        //如果index等于1
        if (index == 1) {
            E e = first.next.data;
            first.next = first.next.next;
            size--;
            return e;
        }
        //暂时是头结点,循环结束后指向index索引的节点的next节点
        Node<E> x = first;
        //index索引的前一个节点
        Node<E> y = null;
        //index索引的节点
        Node<E> z = null;
        for (int i = 0; i <= index; i++) {
            x = x.next;
            if (i == index - 2) {
                y = x;
            }
            if (i == index - 1) {
                z = x;
            }
        }
        y.next = x;
        E e = z.data;
        size--;
        z = null;
        return e;
    }

    /**
     * 获取元素数量
     */
    public int size() {
        return size;
    }


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


    /**
     * 检查索引是否越界，用在删除、获取
     */
    private void checkElementIndex(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
    }


    /**
     * 检查索引是否越界，用在添加
     */
    private void checkPositionIndex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
    }
}
2.2.3.1 测试
MySingleLinkedList<Object> objectMySingleLinkedList = new 
MySingleLinkedList<>();
objectMySingleLinkedList.add(111);
objectMySingleLinkedList.add(222);
objectMySingleLinkedList.add(333);

System.out.println(objectMySingleLinkedList.remove(0));
objectMySingleLinkedList.add(444, 0);

System.out.println(objectMySingleLinkedList);

2.3 静态链表

2.3.1 静态链表的概述

对于一些高级语言比如C，具有指针，Java、C#具有对象引用间接的实现了指针，因此可以使用指针或者对象引用建的实现单链表，但是对于如Basic、Fortran等早期的编程高级语言，由于没有指针/对象引用，链表结构按照前面我们的办法，它就没法实现了。

可以用对象数组代替指针实现链式存储结构，我们说链式存储结构的特点在于，存储位置可以不相邻，数据间的逻辑关系可以被描述，只要我们利用数组实现这两个需求，就可以达到用数组实现链式存储结构的目的。

在这里插入图片描述

对象数组中的对象就是链表中的节点，该节点包含两部分：数据域和指针域。数据域就是存放对象的，而这个“指针域”实际上存放的是下一个节点所在的数组元素的下标索引，利用数组的下标索引巧妙地当作指针，来查找下一个元素的位置，非常的巧妙。

为了实现类似单链表的申请、释放结点的功能，可以将这个数组分为两部分，一部分用来存储数据，另一部分作为备用空闲链表，这都是“逻辑上的链表”。备用链表，即连接各个空闲位置的链表，当存放数据时，从空闲列表的第一个空闲位置开始存放；当删除数据时，把指定索引处的数据删除。之后只需要修改“指针”——下标索引即可，不必再移动其他元素。

为了保存数组“数据链表”和“空闲链表”的“头指针”——起始索引，我们需要两个额外变量来存储。

2.3.2 静态链表的简单实现

/**
 * 静态链表的简单实现,为了简单,该实现的底层数组设计为不可扩展
 */
public class MyStaticLinkedList<E> {

    /**
     * 采用数组实现链式存储
     */
    private final Node<E>[] elements;

    /**
     * 容量
     */
    private final int capcity;

    /**
     * 数据链表的头结点索引
     */
    private int datafirst;

    /**
     * 空闲链表的头结点索引
     */
    private int freefirst;

    /**
     * 元素个数
     */
    private int size;

    /**
     * 构造器
     */
    public MyStaticLinkedList(int capcity) {
        if (capcity <= 0) {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    capcity);
        }
        this.capcity = capcity;
        this.elements = new Node[capcity];
    }


    /**
     * 单链表内部的节点
     */
    private static class Node<E> {
        //下一个结点的引用,这里采用数组下标索引来表示
        Integer next;
        //结点数据
        E data;

        //节点构造器
        private Node(E data, Integer next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "next=" + next +
                    ", data=" + data +
                    '}';
        }
    }

    /**
     * 默认 添加元素到单链表尾部
     * @param e 要添加的元素
     * @return true 添加成功 false 添加失败
     */
    public boolean add(E e) {
        if (checkCapcity()) {
            return false;
        }
        //创建新节点
        Node<E> newNode = new Node(e, null);
        if (size == 0) {
            elements[freefirst] = newNode;
            freefirst = 1;
        } else {
            //寻找尾节点
            Node<E> firstNode = elements[datafirst];
            while (firstNode.next != null) {
                firstNode = elements[firstNode.next];
            }
            firstNode.next = freefirst;
            elements[freefirst] = newNode;
            //寻找下一个空闲链表头部
            findFreeFirst();
        }
        size++;
        return true;
    }

    /**
     * 默认 删除单链表头部元素
     * @return 被删除的元素
     */
    public E remove() {
        if (size == 0) {
            return null;
        } else {
            Node<E> first = elements[datafirst];
            E e = first.data;
            Integer nextIndex = first.next;
            if (nextIndex == null) {
                datafirst = 0;
                freefirst = 0;
                elements[datafirst] = null;
            } else {
                elements[datafirst] = null;
                datafirst = nextIndex;
                //寻找下一个空闲链表头部
                findFreeFirst();
            }
            size--;
            return e;
        }

    }


    /**
     * 添加元素到链表指定索引位置，原索引节点链接为next
     * @param e 要添加的元素
     * @param index 指定索引
     * @return true 添加成功 false 添加失败
     */
    public boolean add(E e, int index) {
        checkPositionIndex(index);
        if (checkCapcity()) {
            return false;
        }
        if (index == size) {
            add(e);
        } else if (index == 0) {
            //新建节点
            elements[freefirst] = new Node<>(e, datafirst);
            //更新数据链表的头结点
            datafirst = freefirst;
            //寻找下一个空闲链表的头结点
            findFreeFirst();
        } else {
            //寻找指定节点的前一个节点
            Node<E> preNode = getNode(index - 1);
            //新建节点
            elements[freefirst] = new Node<>(e, preNode.next);
            //改变"索引"
            preNode.next = freefirst;
            //寻找下一个空闲链表头部
            findFreeFirst();
        }
        size++;
        return true;
    }


    /**
     * 删除链表指定索引元素
     *
     * @param index 指定索引
     * @return 被删除的元素
     */
    public E remove(int index) {
        checkElementIndex(index);
        if (size == 0) {
            return null;
        } else if (index == 0) {
            return remove();
        } else {
            //获取被删除元素的前一个前驱元素
            Node<E> preNode = getNode(index - 1);
            //获取当前元素的索引
            Integer nodeIndex = preNode.next;
            Node<E> node = elements[nodeIndex];
            E data = node.data;
            //改变"指针"
            preNode.next = node.next;
            //被删除的元素位置置空,让GC来回收
            elements[nodeIndex] = null;
            //调整空闲链表的头结点索引
            if (nodeIndex < freefirst) {
                freefirst = nodeIndex;
            }
            size--;
            return data;
        }

    }


    /**
     * 获取指定链表索引的元素
     *
     * @param index 索引
     * @return 索引处的元素
     */
    public E get(int index) {
        checkElementIndex(index);
        return getNode(index).data;
    }


    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            Node<E> node = elements[datafirst];
            stringBuilder.append(node.data).append(", ");
            while (node.next != null) {
                node = elements[node.next];
                stringBuilder.append(node.data);
                if (node.next != null) {
                    stringBuilder.append(" ,");
                }
            }
            return stringBuilder.toString();
        }
    }

    /***
     * 增强toString ,用于测试
     */
    public String toStringAll() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[ ");
        for (int i = 0; i < elements.length; i++) {
            Node<E> node = elements[i];
            if (node != null) {
                stringBuilder.append(node.toString());
            } else {
                stringBuilder.append("null");
            }
            if (i != elements.length - 1) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append(" ]");
        stringBuilder.append("{ freefirst:").append(freefirst);
        stringBuilder.append(", datafirst: ").append(datafirst);
        stringBuilder.append(", size: ").append(size).append(" }");
        return stringBuilder.toString();
    }


    /**
     * 寻找下一个空闲链表头部
     */
    private void findFreeFirst() {
        for (int i = 0; i < elements.length; i++) {
            if (elements[i] == null) {
                freefirst = i;
                break;
            }
        }
    }


    /**
     * 获取指定位置的节点
     *
     * @param index 指定索引
     * @return 节点
     */
    private Node<E> getNode(int index) {
        /*寻找节点*/
        Node<E> firstNode = elements[datafirst];
        for (int i = 0; i < index; i++) {
            firstNode = elements[firstNode.next];
        }
        return firstNode;
    }


    /**
     * 检查索引是否越界，用在删除、获取
     */
    private void checkElementIndex(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
    }


    /**
     * 检查索引是否越界，用在添加
     */
    private void checkPositionIndex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
    }


    /**
     * 检查容量
     */
    private boolean checkCapcity() {
        return size == capcity;
    }
}
2.3.2.1 测试
      MyStaticLinkedList<Object> objectMyStaticLinkedList = new MyStaticLinkedList<>(6);
        boolean add2 = objectMyStaticLinkedList.add(22);
        boolean add3 = objectMyStaticLinkedList.add(33);
        objectMyStaticLinkedList.remove();
        System.out.println(objectMyStaticLinkedList);
        boolean add4 = objectMyStaticLinkedList.add(44);
        System.out.println(objectMyStaticLinkedList);
        boolean add5 = objectMyStaticLinkedList.add("55");
        boolean add6 = objectMyStaticLinkedList.add("66");
        boolean add7 = objectMyStaticLinkedList.add("77");
        boolean add8 = objectMyStaticLinkedList.add("88");
        System.out.println(objectMyStaticLinkedList);
        objectMyStaticLinkedList.remove();
        System.out.println(objectMyStaticLinkedList);
        boolean add9 = objectMyStaticLinkedList.add("99");
        System.out.println(objectMyStaticLinkedList);
        objectMyStaticLinkedList.remove();
        System.out.println(objectMyStaticLinkedList);

        System.out.println(objectMyStaticLinkedList.get(3));
        System.out.println(objectMyStaticLinkedList.get(0));

        System.out.println(objectMyStaticLinkedList);

        objectMyStaticLinkedList.add(1, 1);
        System.out.println(objectMyStaticLinkedList);


        Object remove = objectMyStaticLinkedList.remove(0);
        System.out.println(remove);
        System.out.println(objectMyStaticLinkedList);


        Object remove2 = objectMyStaticLinkedList.remove(3);
        System.out.println(remove2);
        System.out.println(objectMyStaticLinkedList);

        System.out.println(objectMyStaticLinkedList.toStringAll());

2.4 循环链表

我们也可以在单链表尾部使用指针，并且让它指向链表头部的数据，将链表变成环形。这便是“循环链表”，也叫“环形链表”。循环链表没有头和尾的概念。想要保存数量固定的最新数据时通常会使用这种链表。

循环链表可以解决了一个很麻烦的问题：如何从当中一个结点出发，访问到链表的全部结点。

循环链表和单链表的主要差异就在于循环的判断条件上，单链表判断循环结束为：node->next==NULL;而循环链表判断循环结束为：（node->next）等于头结点。实际上循环链表是没有头结点的，这里的头结点只是人为设置的，相当于一个标记，当从“头结点”开始遍历，如果又回到了“头结点”，那么该循环链表就算遍历完毕了。

为了更方便的遍历循环链表，我们可以把指针指向“尾节点“，而不是“头结点”。

在这里插入图片描述

这样就能在O(1)时间内访问到,链表的头尾节点。

循环链表实际上还是比较简单的，再次就不给出实现案例了。

2.5 双向链表

在单链表中，有了next指针，这就使得我们要查找下一结点的时间复杂度为O(1)。可是如果我们要查找的是上一结点的话，那最坏的时间复杂度就是O(n)了，因为我们每次都要从头开始遍历查找。

为了克服单向性这一缺点，我们可以把一个节点拥有的指针设定为两个，并且让它们分别指向该节点的前驱节点和后继节点，这就是“双向链表”。使用这种链表，不仅可以从前往后，还可以从后往前遍历数据，十分方便。

但是，双向链表存在两个缺点：一是指针数的增加会导致存储空间需求增加；二是添加和删除数据时需要改变更多指针的指向。

我们Java中的LinkedList集合就是双向链表，因此再次不在实现双向链表了。该结构也是比较简单的，去看LinkedList的源码就能很快知道怎么实现了。

在这里插入图片描述

单向循环链表则被用来解决约瑟夫环的问题。双向链表也可以有循环链表的变种，但是很少用到：头结点的prev指针指向尾节点，尾节点的next指针指向头结点。

3 总结

本次主要讲解了线性表的顺序 存储结构和链式存储结构的基本原理,并且均有相应的实现案例，比如采用数组实现线性表、单链表的实现、静态链表的实现，由于Linkedlist就是采用的双向链表实现的，因此并未给出双向链表的实现。可以看出来，线性表还算是一种非常简单的数据结构了，此外，还有栈、队列等特殊的线性表在本文中还未讲解，留待下次讲解。

相关文章：

  1. 《大话数据结构》
  2. 《算法图解》
  3. 《我的第一本算法书》

如果有什么不懂或者需要交流，可以留言。另外希望点赞、收藏、关注，我将不间断更新各种Java学习博客！

刘Java
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java数据结构——线性表
m0_51274044的博客
11-28 1360
线性表的顺序表示和实现 线性表的顺序表示形式： 用一组地址连续的存储单元依次存储线性表中的数据元素 在接口中定义方法： package qianyu.ch02; public interface MyArrayList { //定义一些方法 //查询线性表中数据元素个数 int getSize(); //判断线性表是否为空 boolean isEmpty(); //在线性表指定索引位置处插入元素 void insert(int i,Object e); //判断线性表中是否存在元素.
Java数据结构之线性表
08-31
Java中的线性表是一种基本的数据结构，它由一系列具有线性关系的元素构成，这些元素在逻辑上形成一个序列。线性表支持多种操作，包括获取元素、设置元素值、遍历、插入、删除、查找、替换和排序。线性表的存储方式有...
java实现线性表的案例_数据结构—线性表(LinearList)的原理以及Java实现案例
weixin_39828783的博客
03-04 308
线性表：零个或多个数据元素的有限序列。包括数组、链表、栈空间、队列等结构都属于线性表。 本文将介绍Java线性表中的数组、链表的实现逻辑，并附有数组线性表、单链表、静态链表的Java实现源码。数据结构入门以及分类介绍。1 线性表的顺序存储结构1.1 线性表顺序存储结构概述线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。线性表(a1,a2,…,an)的顺序存储示意图如下...
java_linear list
weixin_34389926的博客
11-25 119
1.线性表的顺序存储结构,类似ArrayList package collectionsFramework.linearlist; import java.util.Arrays; /** * @Package collectionsFramework.linearlist * @ClassName: Singlylinkedlist * @Descri...
Java中的数据结构（线性表）
willim_zhao的博客
10-14 175
线性表 1.什么是线性表？ 像a1,a2,a3…an这样的有限序列，成为线性表 2.线性表的表示形式： ①. 顺序表（ArrayList） ②.链表（LinkedList） 3.线性表接口提供的函数（List）: 4.在java中的关系
数据结构之线性表(十)——案例分析
daocaoren_的博客
07-22 647
多项式运算 一元多项式运算：实现两个多项式的加、减、乘运算。 Pn(x)=p0+p1x+p2x2+...+pnxnP_n(x)=p_0+p_1x+p_2x^2+...+p_nx^nPn​(x)=p0​+p1​x+p2​x2+...+pn​xn 这里的多项式系数就可以保存在线性表P中。 两个多项式相加运算： 稀疏多项式运算 ...
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
C++ 数据结构线性表-数组实现
08-30
总的来说，C++中的线性表数组实现涉及到了动态内存分配、对象生命周期管理、数组操作以及基本数据结构的操作方法实现。这样的实现允许高效地访问和修改数组内的元素，但由于数组大小固定，插入和删除操作在表满或...
c语言数据结构线性表创建删除插入
06-30
对于C语言数据结构初学者，可以从基础书籍如《C语言程序设计》和《数据结构（C语言版）》入手，同时结合在线教程和实践项目进行学习，逐步掌握线性表和其他数据结构的实现和应用。 理解并熟练掌握线性表的创建、...
c++ 数据结构线性表代码实现
最新发布
10-17
本主题将深入探讨如何使用C++来实现线性表这一基本数据结构。 线性表是数据结构中最简单但又十分重要的类型，它是一组相同类型的元素按照特定顺序排列的集合。在C++中，线性表通常有两种常见实现：顺序表...
linearlist
11-26
Java数据结构 线性表 栈和队列 数和二叉树
java中线性表_Java实现线性表（顺序表）
weixin_29558841的博客
02-16 163
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。线性表可通过一维数组来实现其顺序存储结构，即把第一个数据元素存放到数组下标为0的位置中，接着把线性表相邻的元素存储到数组中相邻的位置。顺序存储结构的优缺点：优点：1. 无需为表中元素之间的逻辑关系而增加额外的存储空间2. 可以快速地存取表中任意位置的元素缺点：1. 插入和删除需要移动大量元素顺序存储结构需要三个属性：1....
java数据结构之线性表
sjf_com的博客
05-25 1042
一、数据结构与算法的关系 1.数据结构是研究组织数据的学科 2.程序 = 数据结构+算法 3.数据结构是算法的基础，如果想要学好算法就必须有良好的数据结构基础 二、线性结构与非线性结构 2.1 线性结构 1.数据元素之间存在一对一的对应关系称之为线性关系 2.线性结构有两种不同的存储结构，即顺序存储结构（数组）链式存储结构（链表）。顺接存储的线性表称之为顺序表，即存储的元素是连续的。 3.链式存储的线性表称为链表， 4.线性结构常见的有：数组、队列、链表和栈。 2.2 非线性结构 非线性结构包括：二维数组、
JAVA实现——线性表
niudieyi的博客
04-25 2768
如果一个数据元素序列满足： 除第一个和最后一个数据元素外，每个数据元素都只有一个前驱数据元素和一个后继数据元素； 第一个数据元素没有前驱数据元素； 最后一个数据元素没有后继数据元素； 则称这样的数据结构为线性结构。线性表、堆栈、队列、串和数组都属于线性结构。 线性表是一种可以在任意位置进行插入和删除数据元素操作的、由n（n>=0）个相同类型数据元素a0,a1,a2,a3…..an-1组成的线性结构
java 实现线性表
whc20011的专栏
07-16 832
一、概念 对于常用的数据结构，可分为线性结构和非线性结构，线性结构主要是线性表，非线性结构主要是数和图。当n>0时，表可表示为：(a0,a1,a2,a3,…an) 1、 线性表的特征： 1存在唯一的被称作”第一个”的数据元素 2存在唯一的一个称作”最后一个的”数据元素” 3除第一个之外，集合中的每个数据元素均只有一个前驱 4除最后一个之外，集合中每个元素均只有一个后继 2、线性表的基
java实现线性表
不会停下学习的脚步，重在思考。
03-08 363
线性表的定义:线性表是n个类型相同的数据元素的有限序列。线性表中元素的个数N定义为线性表的长度。当N为0的时候定义为空表，在非空的线性表中每个数据元素在线性表中都有唯一确定的序号。 线性结构是最简单最常用的结构：线性结构的特点是：在数据元素的有限集中，除第一个元素无直接前驱，最后一个元素无直接后续外，每个元素有且仅有一个直接前驱和一个直接后续。 所以线性表和数组有点类似，线性表与数组之间的
Java实现线性表（顺序表）
在梅边的专栏
01-09 1530
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。线性表可通过一维数组来实现其顺序存储结构，即把第一个数据元素存放到数组下标为0的位置中，接着把线性表相邻的元素存储到数组中相邻的位置。 顺序存储结构的优缺点： 优点：1. 无需为表中元素之间的逻辑关系而增加额外的存储空间    2. 可以快速地存取表中任意位置的元素 缺点：1. 插入和删除需要移动大量元素 顺序
JAVA版数据结构-----线性表
qq_37453637的博客
02-03 267
一.线性表 线性表的定义 线性表是具有相同数据类型的 n(n>=0)个数据元素的有限序列，其中n为表长，当 n=0时，是一个空表。若用L命名线性表，则其一般表示为：L = （a1,a2,a3…ai,… an)，在该式子中，a1是唯一的“第 一个”数据元素，又称表头元素；an是唯一的“最后一 个”数据元素，又称表尾元素。除第一个元素外，每个元素有且仅有 一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后驱。 由此，我么得出线性表特点如下： 表中元素的个数有限。 表中元素具有逻辑上的顺序性 表中
2.0 JAVA线性表
xiexieya233的博客
04-11 1619
学习总结 线性表是最基本、最简单、最常田的线性结构、几平所有的程序设计语言中都包含数组这种数据结构，而一个数组中的若干数据元素是按照顺序存储在相邻的计算机内存中，这就是一种典型的线性表。 2.1.1 线性表的定义 线性表(Linear List）是由n(n≥0）个类型相同的数据兀系ao, a,…,an-1组成的有限序列，记作（a, ap,…,an-1)，其中数据元素a可以是整型、实型、字符、布尔或复合类型等任何一种数据类型;n是线性表数据元素的个数，即线性表的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刘Java

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

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

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

打赏作者

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

抵扣说明：

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

余额充值