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

·  阅读 97

「这是我参与11月更文挑战的第13天,活动详情查看:2021最后一次更文挑战」。

详细介绍了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学习博客!

分类:
后端