数据结构：LinkedList与链表
LinkedList与链表（数据结构）
文章目录
- LinkedList与链表（数据结构）
-
- :japanese_goblin:前言：
- 一、链表的概念及结构
- 二、单链表SingleList的模拟实现
- 三、双向链表LinkedList的模拟实现
- 四、LinkedList的使用
-
- 1. LinkedList的构造
- 2. LinkedList 的其他常用方法介绍
- 3. LinkedList 的遍历
- 五、ArrayList（顺序表）和LinkedList（双链表）的区别
前言：
由于ArrayList其底层是一段连续空间，在进行插入或者删除元素时，需要将后序元素整体往前或者往后
搬移，其时间复杂度为O(n)，效率比较低。因此：java集合中又引入了LinkedList，即链表结构。
一、链表的概念及结构
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。
注意：
- head.next存放的是下一个节点的地址。
- 从图中可以看出，链式结构在逻辑上是连续的，但是在物理上不一定连续。
- 节点一般都是从堆上申请出来的。
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
-
单向or双向
-
带头or不带头
-
循环or非循环
ℹ️ 虽然有这么多的链表的结构，但是我们重点掌握两种:
-
无头单向非循环链表（单链表） ：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构。
-
无头双向非循环链表 （LinkedList） :在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Bj0U81E-1681813509420)(C:\Users\28779\AppData\Roaming\Typora\typora-user-images\image-20230416185028084.png)]](http://img.e-com-net.com/image/info8/10aa7ef0df364f048a1d93d57ebee198.jpg)
二、单链表SingleList的模拟实现
模拟实现的SingleList单链表有如下几个功能
- 头插法
- 尾插法
- 在任意位置插入，第一个数据节点为0号下标
- 删除第一次出现关键字为key的节点
- 删除所有值为key的节点
- 查找是否包含关键字key是否在单链表当中
- 得到单链表的长度
- 清空链表
废话不多说，直接上代码：
package demo1;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-09
* Time: 10:05
*/
public class MySingleList {
public class ListNode {
public int val;
public ListNode next;
public ListNode(int val) {
this.val = val;
}
}
public ListNode head;
public void createList() {
ListNode node1 = new ListNode(12);
ListNode node2 = new ListNode(12);
ListNode node3 = new ListNode(12);
ListNode node4 = new ListNode(45);
ListNode node5 = new ListNode(56);
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
this.head = node1;
}
public void showList() {
ListNode cur = head;
while(cur != null) {
System.out.print(cur.val + " ");
cur = cur.next;
}
}
//得到单链表的长度
public int size() {
ListNode cur = head;
int count = 0;
while(cur != null) {
count++;
cur = cur.next;
}
return count;
}
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key) {
ListNode cur = head;
while(cur != null){
if(cur.val == key) {
return true;
}
cur = cur.next;
}
return false;
}
//头插法
public void addFirst(int data){
ListNode node = new ListNode(data);
node.next = head;
head = node;
}
//尾插法
public void addLast(int data){
ListNode node = new ListNode(data);
if(head == null){
head = node;
return;
}
ListNode cur = head;
while(cur.next != null){
cur = cur.next;
}
cur.next = node;
}
//任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data) {
ListNode node = new ListNode(data);
int len = size();
if(index < 0 || index > len) {
throw new IndexOutOfBounds("任意位置插入数据的时候，index位置不合法" + index);
}
if(index == 0) {
addFirst(data);
return;
}
if(index == len) {
addLast(data);
return;
}
ListNode cur = head;
for (int i = 0; i < index - 1; i++) {
cur = cur.next;
}
node.next = cur.next;
cur.next = node;
}
//删除第一次出现关键字为key的节点
public void remove(int key) {
if(head == null) {
return;
}
if(head.val == key) {
head = head.next;
return;
}
ListNode prev = searchPrev(key); //找前驱节点
if(prev == null) {
System.out.println("没有这个数据！！");
return;
}
ListNode del = prev.next;
prev.next = del.next;
}
private ListNode searchPrev(int key) {
ListNode prev = head;
while (prev.next != null) {
if(prev.next.val == key) {
return prev;
}
else {
prev = prev.next;
}
}
return null;
}
//删除所有值为key的节点
public void removeAllKey(int key){ //利用快慢指针
if(head == null) {
return;
}
ListNode cur = head.next;
ListNode prev = head;
while(cur != null){
if(cur.val == key) {
prev.next = cur.next;
cur = cur.next;
}
else {
prev = cur;
cur = cur.next;
}
}
if(head.val == key){
head = head.next;
}
}
//清空链表
public void clear(){
//this.head = null;
while (head != null){
ListNode headNext = head.next;
head.next = null;
head = headNext;
}
}
}
以下是测试+异常代码：
package demo1;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-09
* Time: 10:05
*/
public class Test { //测试代码
public static void main(String[] args) {
MySingleList mySingleList = new MySingleList();
mySingleList.createList();
mySingleList.showList();
System.out.println();
System.out.println("单链表长度为：" + mySingleList.size());
System.out.println("是否有某元素：" + mySingleList.contains(13));
mySingleList.addFirst(10); //头插法
mySingleList.showList();
System.out.println();
mySingleList.addLast(100); //尾插法
mySingleList.showList();
System.out.println();
try {
mySingleList.addIndex(2, 1000); //在下标为index的位置上添加一个数data
}catch (IndexOutOfBounds indexOutOfBounds){
indexOutOfBounds.printStackTrace();
}
//mySingleList.addIndex(111, 1000);
mySingleList.showList();
System.out.println();
mySingleList.remove(100); //移除key单个关键字
mySingleList.showList();
System.out.println();
mySingleList.removeAllKey(12); //移除所有的key关键字
mySingleList.showList();
System.out.println();
mySingleList.clear(); //清空链表
mySingleList.showList();
}
}
package demo1;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-09
* Time: 10:50
*/
public class IndexOutOfBounds extends RuntimeException { //异常代码
public IndexOutOfBounds() {
}
public IndexOutOfBounds(String message) {
super(message);
}
}
三、双向链表LinkedList的模拟实现
模拟实现的LinkedList双向链表功能与单链表功能一样（各个功能的实现均与单链表的相似，这里就不再赘述）
1.头插法
2.尾插法
3.任意位置插入,第一个数据节点为0号下标
4.查找是否包含关键字key是否在单链表当中
5.删除第一次出现关键字为key的节点
6.删除所有值为key的节点
7.得到单链表的长度
废话不多说，直接上代码：
package imitate_LinkedList;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-14
* Time: 15:36
*/
public class MyLinkedList {
static class ListNode {
public int val;
public ListNode prev;
public ListNode next;
public ListNode(int val) {
this.val = val;
}
}
public ListNode head;
public ListNode last;
//得到双向列表的长度
public int size(){
int len = 0;
ListNode cur = head;
while(cur != null){
cur = cur.next;
len++;
}
return len;
}
public void display(){
ListNode cur = head;
while(cur != null){
System.out.print(cur.val + " ");
cur = cur.next;
}
System.out.println();
}
//查找双链表是否存在某个节点
public boolean contains(int key){
ListNode cur = head;
while(cur != null){
if(cur.val == key){
return true;
}
cur = cur.next;
}
return false;
}
//头插法
public void addFirst(int data) {
ListNode node = new ListNode(data);
if(head == null){
head = node;
last = node;
return;
}
head.prev = node;
node.next = head;
head = node;
}
//尾插法
public void addLast(int data) {
ListNode node = new ListNode(data);
if(head == null){
addFirst(data);
return;
}
last.next = node;
node.prev = last;
last = node;
}
//在某个下标为index的节点处新增一个节点
public void addIndex(int index, int data){
if(index < 0 || index > size()){
throw new IndexOutOfBounds("双向列表index不合法！！");
}
if(index == size()) {
addLast(data);
return;
}
if(index == 0){
addFirst(data);
return;
}
ListNode cur = head;
while(index != 0) {
index -- ;
cur = cur.next;
}
ListNode node = new ListNode(data);
node.prev = cur.prev;
node.next = cur;
cur.prev.next = node;
cur.prev = node;
}
//删除第一次出现关键字为key的节点
public void remove(int key) {
ListNode cur = head;
//头结点为要删除的节点
if(head.val == key) {
head = head.next;
//判断是否只有一个头节点
if(head != null) {
head.prev = null;
return;
}
}
//要删除的节点在中间
while(cur.next != null) {
if(cur.val == key) {
cur.prev.next = cur.next;
cur.next.prev = cur.prev;
return;
}
cur = cur.next;
}
//尾节点为要删除的节点
if(cur.val == key) {
cur.prev.next = null;
last = last.prev;
}
}
//删除所有值为key的节点
public void removeAllKey(int key) {
ListNode cur = head;
while(cur != null) {
if(cur.val == key) {
//判断是否为头结点
if(cur == head) {
head = head.next;
if(head != null) {
head.prev = null;
}else {
last = null;
}
} else {
cur.prev.next = cur.next;
//判断是否为尾节点
if(cur.next != null) {
cur.next.prev = cur.prev;
} else {
last = last.prev;
}
}
cur = cur.next;
} else {
cur = cur.next;
}
}
}
public void clear(){
ListNode cur = head;
while(cur != null) {
ListNode curNext = cur.next;
cur.next = null;
cur.prev = null;
cur = curNext;
}
head = null;
last = null;
}
}
以下是测试+异常代码：
package imitate_LinkedList;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-14
* Time: 15:44
*/
public class Test {
public static void main(String[] args) {
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addFirst(12);
myLinkedList.addFirst(12);
myLinkedList.addFirst(34);
myLinkedList.addFirst(56);
myLinkedList.display();
myLinkedList.addLast(10);
myLinkedList.display();
myLinkedList.addIndex(5,100);
myLinkedList.display();
//移除第一次出现的关键字key
myLinkedList.remove(12);
myLinkedList.display();
//移除全部key
myLinkedList.removeAllKey(12);
myLinkedList.display();
//清空双链表的内容
myLinkedList.clear();
myLinkedList.display();
}
}
package imitate_LinkedList;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 28779
* Date: 2023-04-14
* Time: 17:29
*/
public class IndexOutOfBounds extends RuntimeException{
public IndexOutOfBounds() {
}
public IndexOutOfBounds(String message) {
super(message);
}
}
四、LinkedList的使用
1. LinkedList的构造
| 方法 | 解释 |
|---|---|
| LinkedList() | 无参构造 |
| public LinkedList(Collection c) | 使用其他集合容器中元素构造List |
public static void main(String[] args) {
// 构造一个空的LinkedList
List<Integer> list1 = new LinkedList<>();
List<String> list2 = new java.util.ArrayList<>();
list2.add("JavaSE");
list2.add("JavaWeb");
list2.add("JavaEE");
// 使用ArrayList构造LinkedList
List<String> list3 = new LinkedList<>(list2);
}
2. LinkedList 的其他常用方法介绍
| 方法 | 解释 |
|---|---|
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List subList(int fromIndex, int toIndex) | 截取部分 list |
3. LinkedList 的遍历
LinkedList可以使用三方方式遍历：for循环+下标、foreach、使用 正序/逆序 迭代器。
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
// 使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
}
System.out.println();
}
五、ArrayList（顺序表）和LinkedList（双链表）的区别
| 不同点 | ArrayList（单链） | LinkedList（双链） |
|---|---|---|
| 存储空间上 | 物理上一定连续 | 逻辑上连续，但物理上不一定连续 |
| 随机访问 | 支持O(1) | 不支持：O(N) |
| 头插 | 需要搬移元素，效率低O(N) | 只需修改引用的指向，时间复杂度为O(1) |
| 插入 | 空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效率查询 | 任意位置插入和删除频繁 |
