Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

最新推荐文章于 2023-09-18 14:59:36 发布

caobing123321

最新推荐文章于 2023-09-18 14:59:36 发布

阅读量651

点赞数 1

分类专栏：高可用高性能高并发文章标签：高可用高性能

高可用同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

高性能

6 篇文章 0 订阅

订阅专栏

高并发

6 篇文章 0 订阅

订阅专栏

数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目，

它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少在一段时间之后，技术可以很快得到提高。同时，它也是软考的重点，我们需要对这部分的内容进行一下总结。

我们先看一下数据结构和算法的整体内容。

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

1、线性表

概念：

数据元素的排列方式是线性的。

分类：

分类规则是根据上图中元素的存储结构来划分的。

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

（1）顺序表

基本思想：元素的存储空间是连续的。在内存中是以顺序存储，内存划分的区域是连续的。存储结构如下图：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

（2）链表

基本思想：元素的存储空间是离散的，单独的（物理），它们可以通过在逻辑上指针的联系使得它成为了整体的链表。存储结构如下图：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

1.单链表

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

2.循环链表

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

3.双链表（双向循环表）

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

（图有点小问题：最后一个节点的指针域也指向头结点）

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

三者的区别（从上面三个图我们可以总结出来）：

1、它们都有数据域（data(p)）和指针域(next(p))，但是从图中可以看出双链表有两个指针域，一个指向它的前节点，一个指向它的后节点。

2、单链表最后一个节点的指针域为空，没有后继节点；循环链表和双链表最后一个节点的指针域指向头节点，下一个结点为头节点，构成循环；

3、单链表和循环链表只可向一个方向遍历；双链表和循环链表，首节点和尾节点被连接在一起，可视为“无头无尾”；双链表可以向两个方向移动，灵活度更大。

线性表操作：

理解了顺序表和链表的基本思想之后，线性表的操作是简单，并且网上有很多讲解插入和删除结点的博客，在这里我就不过多的介绍了。

顺序表和链表的对比：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

栈和队列是特殊的线性表，既然特殊就有不同点。

2、栈

基本思想：后进先出（先进后出）即栈中元素被处理时，按后进先出的顺序进行，栈又叫后进先出表（LIFO）。

举例：

日常生活中有很多栈的例子。例如，放在书桌上的一摞书，只能从书顶上拿走一本书，书也只能放在顶上。如下图所示：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

3、队列

基本思想：先进先出即先被接收的元素将先被处理，又叫先进先出表（FIFO）。如下图所示：

举例：

队列的例子，生活中更多。比如：买车票排队，排头最先买到车票，新来的排的队尾；进车站时，安检行李，先进去的最先出来，后进去的后出来。

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

分类：

1.顺序队列

如下图所示：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

顺序队列的操作，要判断队满和队空的标志，从图中我们可以总结得到：

1.队空：head = tail

2.队满：tail = m

2.循环队列

如下图所示：

Java数据结构与算法—及实现线性表顺序表、链表、栈、队列详解

循环队列的操作，要判断队空和队满的情况，从图中我们可以总结得到：

1.队空：head = tail

2.队满：tail + 1 = head(在队列中会留一个空着的空间，所以要加1)

总结

线性表真的很简单。

----------------------------------------------------------------------------------------------------

数据结构中的线性表，对应着Collection接口中的List接口。

在本节中，我们将做以下三件事

第一。我们先来看看线性表的特征

第二，自己用JAVA实现List

第三，对比的线性表、链式表性能，以及自己的List性能与JDKList性能对比

线性表特征：

第一，一个特定的线性表，应该是用来存放特定的某一个类型的元素的（元素的“同一性”）

第二，除第一个元素外，其他每一个元素有且仅有一个直接前驱；除最后一个元素外，其他每一个元素有且仅有一个直接后继（元素的“序偶性”）

第三，元素在线性表中的“下标”唯一地确定该元素在表中的相对位置（元素的“索引性”）

又，一.线性表只是数据的一种逻辑结构，其具体存储结构可以为顺序存储结构和链式储存结构来完成，对应可以得到顺序表和链表，

二.对线性表的入表和出表顺序做一定的限定，可以得到特殊的线性表，栈(FILO)和队列（FIFO）

自己实现线性表之顺序表

思路：

1. 顺序表因为采用顺序存储形式，所以内部使用数组来存储数据

2.因为存储的具体对象类型不一定，所以采用泛型操作

3.数组操作优点：1.通过指针快速定位到下表，查询快速

缺点：1.数组声明时即需要确定数组大小。当操作中超过容量时，则需要重新声明数组，并且复制当前所有数据

2.当需要在中间进行插入或者删除时，则需要移动大量元素（size-index个）

具体实现代码如下

Java代码

/**
* 自己用数组实现的线性表
*/
public class ArrayList<E> {
Object[] data = null;// 用来保存此队列中内容的数组
int current; // 保存当前为第几个元素的指标
int capacity; // 表示数组大小的指标
/**
* 如果初始化时，未声明大小，则默认为10
*/
public ArrayList() {
this(10);
}
/**
* 初始化线性表，并且声明保存内容的数组大小
* @param initalSize
*/
public ArrayList(int initalSize) {
if (initalSize < 0) {
throw new RuntimeException("数组大小错误:" + initalSize);
} else {
this.data = new Object[initalSize];
this.current = 0;
capacity = initalSize;
}
}
/**
* 添加元素的方法添加前，先确认是否已经满了
* @param e
* @return
*/
public boolean add(E e) {
ensureCapacity(current);// 确认容量
this.data[current] = e;
current++;
return true;
}
/**
* 确认系统当前容量是否满足需要,如果满足，则不执行操作如果不满足，增加容量
* @param cur 当前个数
*/
private void ensureCapacity(int cur) {
if (cur == capacity) {
// 如果达到容量极限，增加10的容量，复制当前数组
this.capacity = this.capacity + 10;
Object[] newdata = new Object[capacity];
for (int i = 0; i < cur; i++) {
newdata[i] = this.data[i];
}
this.data = newdata;
}
}
/**
* 得到指定下标的数据
* @param index
* @return
*/
public E get(int index) {
validateIndex(index);
return (E) this.data[index];
}
/**
* 返回当前队列大小
* @return
*/
public int size() {
return this.current;
}
/**
* 更改指定下标元素的数据为e
* @param index
* @param e
* @return
*/
public boolean set(int index, E e) {
validateIndex(index);
this.data[index] = e;
return true;
}
/**
* 验证当前下标是否合法，如果不合法，抛出运行时异常
* @param index 下标
*/
private void validateIndex(int index) {
if (index < 0 || index > current) {
throw new RuntimeException("数组index错误：" + index);
}
}
/**
* 在指定下标位置处插入数据e
* @param index 下标
* @param e 需要插入的数据
* @return
*/
public boolean insert(int index, E e) {
validateIndex(index);
Object[] tem = new Object[capacity];// 用一个临时数组作为备份
//开始备份数组
for (int i = 0; i < current; i++) {
if (i < index) {
tem[i] = this.data[i];
}else if(i==index){
tem[i]=e;
}else if(i>index){
tem[i]=this.data[i-1];
}
}
this.data=tem;
return true;
}
/** * 删除指定下标出的数据<br>
* @param index<br>
* @return<br>
*/
public boolean delete(int index){
validateIndex(index);
Object[] tem = new Object[capacity];// 用一个临时数组作为备份
//开始备份数组
for (int i = 0; i < current; i++) {
if (i < index) {
tem[i] = this.data[i];
}else if(i==index){
tem[i]=this.data[i+1];
}else if(i>index){
tem[i]=this.data[i+1];
}
}
this.data=tem;
return true;
}
}

自己实现线性表之链表

思路：1.链表采用链式存储结构，在内部只需要将一个一个结点链接起来。（每个结点中有关于此结点下一个结点的引用）

链表操作优点：1.因为每个结点记录下个结点的引用，则在进行插入和删除操作时，只需要改变对应下标下结点的引用即可

缺点：1.要得到某个下标的数据，不能通过下标直接得到，需要遍历整个链表。

实现代码如下

Java代码

/**
* 自己用链式存储实现的线性表
*/
public class LinkedList<E> {
private Node<E> header = null;// 头结点
int size = 0;// 表示数组大小的指标
public LinkedList() {
this.header = new Node<E>();
}
public boolean add(E e) {
if (size == 0) {
header.e = e;
} else {
// 根据需要添加的内容，封装为结点
Node<E> newNode = new Node<E>(e);
// 得到当前最后一个结点
Node<E> last = getNode(size-1);
// 在最后一个结点后加上新结点
last.addNext(newNode);
}
size++;// 当前大小自增加1
return true;
}
public boolean insert(int index, E e) {
Node<E> newNode = new Node<E>(e);
// 得到第N个结点
Node<E> cNode = getNode(index);
newNode.next = cNode.next;
cNode.next = newNode;
size++;
return true;
}
/**
* 遍历当前链表，取得当前索引对应的元素
*
* @return
*/
private Node<E> getNode(int index) {
// 先判断索引正确性
if (index > size || index < 0) {
throw new RuntimeException("索引值有错：" + index);
}
Node<E> tem = new Node<E>();
tem = header;
int count = 0;
while (count != index) {
tem = tem.next;
count++;
}
return tem;
}
/**
* 根据索引，取得该索引下的数据
*
* @param index
* @return
*/
public E get(int index) {
// 先判断索引正确性
if (index >= size || index < 0) {
throw new RuntimeException("索引值有错：" + index);
}
Node<E> tem = new Node<E>();
tem = header;
int count = 0;
while (count != index) {
tem = tem.next;
count++;
}
E e = tem.e;
return e;
}
public int size() {
return size;
}
/**
* 设置第N个结点的值
*
* @param x
* @param e
* @return
*/
public boolean set(int index, E e) {
// 先判断索引正确性
if (index > size || index < 0) {
throw new RuntimeException("索引值有错：" + index);
}
Node<E> newNode = new Node<E>(e);
// 得到第x个结点
Node<E> cNode = getNode(index);
cNode.e = e;
return true;
}
/**
* 用来存放数据的结点型内部类
*/
class Node<e> {
private E e;// 结点中存放的数据
Node<E> next;// 用来指向该结点的下一个结点
Node() { }
Node(E e) {
this.e = e;
}
// 在此结点后加一个结点
void addNext(Node<E> node) {
next = node;
}
}
}

自己实现线性表之栈

栈是限定仅允许在表的同一端（通常为“表尾”）进行插入或删除操作的线性表。

允许插入和删除的一端称为栈顶(top)，另一端称为栈底(base)

特点：后进先出 (LIFO)或，先进后出（FILO）

因为栈是限定线的线性表，所以，我们可以调用前面两种线性表，只需要对出栈和入栈操作进行设定即可

具体实现代码

Java代码

/**

* 自己用数组实现的栈
*/
public class ArrayStack<E> {
private ArrayList<E> list=new ArrayList<E>();//用来保存数据线性表<br> private int size;//表示当前栈元素个数
/**
* 入栈操作
* @param e
*/
public void push(E e){
list.add(e);
size++;
}
/**
* 出栈操作
* @return
*/
public E pop(){
E e= list.get(size-1);
size--;
return e;
}
}