03数据结构和算法(Java描述)~单链表
本文是上一篇文章的后续,详情点击该链接
链表
单链表
单链表的定义
单链表采用的是链式存储结构,使用一组地址任意的存储单元来存放数据元素。在单链表中, 存储的每一条数据都是以节点来表示的,每个节点的构成为:元素(存储数据的存储单元) + 指 针(存储下一个节点的地址值),单链表的节点结构如下图所示:
另外,单链表中的开始节点,我们又称之为首节点;单链表中的终端节点,我们又称之为尾节 点。如下图所示:
根据序号获取结点的操作:
在线性表中,每个节点都有一个唯一的序号,该序号是从 0开始递增的。通过序号获取单链表 的节点时,我们需要从单链表的首节点开始,从前往后循环遍历,直到遇到查询序号所对应的节点 时为止。
以下图为例,我们需要获得序号为2的节点,那么就需要依次遍历获得“节点 11”和“节点 22”, 然后才能获得序号为 2的节点,也就是“节点 33”。
因此,在链表中通过序号获得节点的操作效率是非常低的,查询的时间复杂度为 O(n)。
根据序号删除节点的操作
根据序号删除节点的操作,我们首先应该根据序号获得需要删除的节点,然后让“删除节点的 前一个节点”指向“删除节点的后一个节点”,这样就实现了节点的删除操作。
以下图为例,我们需要删除序号为2的节点,那么就让“节点22”指向“节点44”即可,这样 就删除了序号为 2的节点,也就是删除了“节点 33”。
通过序号来插入节点,时间主要浪费在找正确的删除位置上,故时间复杂度为 O(n)。但是,单 论删除的操作,也就是无需考虑定位到删除节点的位置,那么删除操作的时间复杂度就是 O(1)。
根据序号插入节点的操作
根据序号插入节点的操作,我们首先应该根据序号找到插入的节点位置,然后让“插入位置的 上一个节点”指向“新插入的节点”,然后再让“新插入的节点”指向“插入位置的节点”,这样 就实现了节点的插入操作。
以下图为例,我们需要在序号为 2 的位置插入元素值“00”,首先先把字符串“00”封装为一 个节点对象,然后就让“节点 22”指向“新节点 00”,最后再让“节点00”指向“节点 33”,这 样就插入了一个新节点。
通过序号来插入节点,时间主要浪费在找正确的插入位置上,故时间复杂度为 O(n)。但是,单 论插入的操作,也就是无需考虑定位到插入节点的位置,那么插入操作的时间复杂度就是 O(1)。
顺序表和单链表的比较
存储方式比较
顺序表采用一组地址连续的存储单元依次存放数据元素,通过元素之间的先后顺序来确定元素 之间的位置,因此存储空间的利用率较高
单链表采用一组地址任意的存储单元来存放数据元素,通过存储下一个节点的地址值来确定节 点之间的位置,因此存储空间的利用率较低。
存储方式比较
顺序表查找的时间复杂度为 O(1),插入和删除需要移动元素,因此时间复杂度为 O(n)。若是需 要频繁的执行查找操作,但是很少进行插入和删除操作,那么建议使用顺序表。
单链表查找的时间复杂度为 O(n),插入和删除无需移动元素,因此时间复杂度为 O(1)。若是需 要频繁的执行插入和删除操作,但是很少进行查找操作,那么建议使用链表。
补充:根据序号来插入和删除节点,需要通过序号来找到插入和删除节点的位置,那么整体的 时间复杂度为 O(n)。因此,单链表适合数据量较小时的插入和删除操作,如果存储的数据量较大, 那么就建议使用别的数据结构,例如使用二叉树来实现。
空间性能比较
顺序表需要预先分配一定长度的存储空间,如果事先不知道需要存储元素的个数,分配空间过 大就会造成存储空间的浪费,分配空间过小则需要执行耗时的扩容操作。
单链表不需要固定长度的存储空间,可根据需求来进行临时分配,只要有内存足够就可以分配, 在链表中存储元素的个数是没有限制的,无需考虑扩容操作。
代码实现
定义List接口
public interface List {
int size();
void add(Object element);
Object get(int index);
void remove(int index);
void add(int index, Object element);
String toString();
}
SingleLinkedList实现类
public class SingleLinkedList implements List{
// 用于保存单链表中的首节点
private Node headNode;
// 用于保存单链表中的尾节点
private Node lastNode;
// 用于保存单链表中节点的个数
private int size;
// 获取单链表中节点的个数
public int size() {
return this.size;
}
/**
* 添加元素
* @param element 需要添加的数据
*/
public void add(Object element) {
// 1.把需要添加的数据封装成节点对象
Node node = new Node(element);
// 2.处理单链表为空表的情况
if(headNode == null) {
// 2.1把node节点设置为单链表的首节点
headNode = node;
// 2.2把node节点设置为单链表的尾节点
lastNode = node;
}
// 3.处理单链表不是空表的情况
else {
// 3.1让lastNode指向node节点
lastNode.next = node;
// 3.2更新lastNode的值
lastNode = node;
}
// 4.更新size的值
size++;
}
/**
* 根据序号获取元素
* @param index 序号
* @return 序号所对应节点的数据值
*/
public Object get(int index) {
// 1.判断序号是否合法,合法取值范围:[0, size - 1]
if(index < 0 || index >= size) {
throw new IndexOutOfBoundsException("序号不合法,index:" + index);
}
// 2.根据序号获得对应的节点对象
Node node = node(index);
// 3.获取并返回node节点的数据值
return node.data;
}
/**
* 根据序号删除元素
* @param index 序号
*/
public void remove(int index) {
// 1.判断序号是否合法,合法取值范围:[0, size - 1]
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("序号不合法,index:" + index);
}
// 2.处理删除节点在开头的情况
if (index == 0) {
// 2.1获得删除节点的后一个节点
Node nextNode = headNode.next;
// 2.2设置headNode的next值为null
headNode.next = null;
// 2.3设置nextNode为单链表的首节点
headNode = nextNode;
}
// 3.处理删除节点在末尾的情况
else if (index == size - 1) {
// 3.1获得删除节点的前一个节点
Node preNode = node(index - 1);
// 3.2设置preNode的next值为null
preNode.next = null;
// 3.3设置preNode为单链表的尾节点
lastNode = preNode;
}
// 4.处理删除节点在中间的情况
else {
// 4.1获得index-1所对应的节点对象
Node preNode = node(index - 1);
// 4.2获得index+1所对应的节点对象
Node nextNode = preNode.next.next;
// 4.3获得删除节点并设置next值为null
preNode.next.next = null;
// 4.4设置preNode的next值为nextNode
preNode.next = nextNode;
}
// 5.更新size的值
size--;
}
/**
* 根据序号插入元素
* @param index 序号
* @param element 需要插入的数据
*/
public void add(int index, Object element) {
// 1.判断序号是否合法,合法取值范围:[0, size]
if(index < 0 || index > size) {
throw new IndexOutOfBoundsException("序号不合法,index:" + index);
}
// 2.把需要添加的数据封装成节点对象
Node node = new Node(element);
// 3.处理插入节点在开头位置的情况
if(index == 0) {
// 3.1设置node的next值为headNode
node.next = headNode;
// 3.2设置node节点为单链表的首节点
headNode = node;
}
// 4.处理插入节点在末尾位置的情况
else if(index == size) {
// 4.1设置lastNode的next值为node
lastNode.next = node;
// 4.2设置node节点为单链表的尾节点
lastNode = node;
}
// 5.处理插入节点在中间位置的情况
else {
// 5.1获得index-1所对应的节点对象
Node preNode = node(index - 1);
// 5.2获得index所对应的节点对象
Node curNode = preNode.next;
// 5.3设置preNode的next为node
preNode.next = node;
// 5.4设置node的next为curNode
node.next = curNode;
}
// 6.更新size的值
size++;
}
/**
* 根据序号获得对应的节点对象
* @param index 序号
* @return 序号对应的节点对象
*/
private Node node(int index) {
// 1.定义一个零时节点,用于辅助单链表的遍历操作
Node tempNode = headNode;
// 2.定义一个循环,用于获取index对应的节点对象
for(int i = 0; i < index; i++) {
// 3.更新tempNode的值
tempNode = tempNode.next;
}
// 4.返回index对应的节点对象
return tempNode;
}
// 节点类
private static class Node {
/**
* 用于保存节点中的数据
*/
private Object data;
/**
* 用于保存指向下一个节点的地址值
*/
private Node next;
/**
* 构造方法
* @param data
*/
public Node(Object data) {
this.data = data;
}
}
public String toString() {
//判断是否为空,如果为空就直接返回 []
if(headNode == null){
return "[]";
}
StringBuilder stringBuilder = new StringBuilder("[");
Node p = headNode.next;
while(p != null){
stringBuilder.append(p.data + ",");
p = p.next;
}
//最后一个逗号删掉
stringBuilder.deleteCharAt(stringBuilder.length()-1);
stringBuilder.append("]");
return stringBuilder.toString();
}
}
Test
public class Test {
public static void main(String[] args) {
// 1.创建一个对象
List list = new SingleLinkedList();
// 2.添加元素
list.add("11"); // 0
list.add("22"); // 1
list.add("33"); // 2
list.add("44"); // 3
list.add("55"); // 4
//删除
list.remove(0);
//序号添加
list.add(2, "00");
//测试get
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
//toString
System.out.println(list.toString());
}
}