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

线性表：零个或多个数据元素的有限序列。包括数组、链表、栈空间、队列等结构都属于线性表。本文将介绍Java线性表中的数组、链表的实现逻辑，并附有数组线性表、单链表、静态链表的Java实现源码。

数据结构入门以及分类介绍。

1 线性表的顺序存储结构

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

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。线性表(a1,a2,…,an)的顺序存储示意图如下：

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

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

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

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

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

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

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

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

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

向数组中i索引位置添加新数据时：

a) 首先判断如果插入位置不合理，抛出异常；

b) 如果插入后线性表长度大于等于数组长度，则抛出异常或动态增加容量；

c) 遍历i索引处的后面的所有元素，分别将它们都向后移动一个位置；

d) 将要插入元素填入索引i处，表长加1。

向数组中i索引位置删除新数据时：

a) 如果删除位置不合理，抛出异常；

b) 取出删除元素；

c) 遍历i索引处的后面的所有元素，分别将它们都向前移动一个位置；

d) 将原末位元素的值置为null；

e) 表长减1。

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

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

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

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

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

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

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

/**

* 线性表的顺序储存结构的简单数组实现,为了演示方便,设计为不可扩展。

public class MyFinalArrayList {

/**

* 底层使用数组来存储数据

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 objectMyFinalList = new MyFinalArrayList<>(6);

System.out.println("插入元素===============>");

objectMyFinalList.add(null);

objectMyFinalList.add(2);

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个索引数据的算法思路：

先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。

然后声明一个变量f指向链表第一个结点，在循环中初始化j从0开始；

当j

当循环结束，变量f指向的就是我们要找的第i个索引的数据。

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

2.2.2 单链表的增删

在指定索引i处插入数据

a) 先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。

b) 然后通过查找，找到原索引i的元素x，以及原索引i的前驱元素y。

c) 构建一个新的节点z，新节点的后继元素指向原索引元素z.next=x

d) 原索引i的前驱元素y的后继指向新的元素，y.next=z

在指定索引i处删除数据

a) 先判断i是否越界，i<0 || i>size ，如果越界则抛出异常。

b) 然后通过查找，找到原索引i的元素x，以及原索引i的前驱元素y，以及原索引i的后继元素z。

c) 让y的next指向z，y.next=z

d) 回收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 {

/**

* 空构造器,内部的节点均没有初始化,在第一次添加时才会初始化。

public MySingleLinkedList() {

}

/**

* 元素个数

private int size;

/**

* 指向头结点的引用

private Node first;

/**

* 单链表内部的节点

private static class Node {

//下一个结点的引用

Node next;

//结点数据

E data;

//节点构造器

public Node(E data, Node next) {

this.data = data;

this.next = next;

}

/**

* 默认添加元素到单链表尾部

public void add(E e) {

//创建新节点

Node 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 x = first;

//index索引的前一个节点

Node 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 x = first;

//index索引的前一个节点

Node y = null;

//index索引的节点

Node 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 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 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 {

/**

* 采用数组实现链式存储

private final Node[] 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 {

//下一个结点的引用,这里采用数组下标索引来表示

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 newNode = new Node(e, null);

if (size == 0) {

elements[freefirst] = newNode;

freefirst = 1;

} else {

//寻找尾节点

Node 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 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 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 preNode = getNode(index - 1);

//获取当前元素的索引

Integer nodeIndex = preNode.next;

Node 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 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 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 getNode(int index) {

/*寻找节点*/

Node 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 objectMyStaticLinkedList = new MyStaticLinkedList<>(6);

boolean add2 = objectMyStaticLinkedList.add(22);

boolean add3 = objectMyStaticLinkedList.add(33);

objectMyStaticLinkedList.remove();