Java中LinkedList的模拟实现
🍔关于LinkedList
LinkedList的底层是用一个双向链表实现的，即一个结点中除了有一个引用指向下一个结点的地址，还有一个引用指向前一个结点的地址
LinkedList还有三个成员变量：
- 🍂size，表示该链表中结点的个数
- 🍂first，指向链表首结点
- 🍂last，指向链表尾结点
模拟实现LinkedList
🍉准备工作
🍃创建静态内部类ListNode，后续创建结点都需要ListNode来创建新的结点
private static class ListNode<E> {
ListNode<E> pre; //指向前一个结点
ListNode<E> next; //指向下一个结点
E val; //结点的值
public ListNode(E val){
this.val = val;
}
}🍃创建成员变量：first，last，size
private ListNode<E> first; //指向链表首结点
private ListNode<E> last; //指向链表尾结点
private int size; //链表结点的个数🍃重写toString()方法，在进行测试方法的时候需要将链表打印出来
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("[");
if(first == null){
sb.append("]");
}else {
ListNode<E> cur = first;
while(cur.next != null){
sb.append(cur.val);
sb.append(",");
cur = cur.next;
}
sb.append(cur.val);
sb.append("]");
}
return sb.toString();
}🍊头插
🍀在链表的头部插入结点，这里分两种情况：链表为空，链表不为空
🍀链表为空：直接将first，last指向该结点，因为这个结点既是第一个结点，也是最后一个结点
🍀链表不为空：将first的pre执行该结点，再将该结点的next指向first，更新first位置
🍀在结点头插完后，更新size的长度，进行size++
public void addFirst(E e){
ListNode<E> newNode = new ListNode<>(e);
if(first == null){
first = newNode;
last = newNode;
}else {
first.pre = newNode;
newNode.next = first;
first = newNode;
}
size++;
}🍂进行测试：依次头插入1，2，3，4，打印list
MyLinkedList<Integer> list = new MyLinkedList<>();
list.addFirst(1);
list.addFirst(2);
list.addFirst(3);
list.addFirst(4);
System.out.println(list);🍀打印结果：因为是头插，所以打印4，3，2，1
尾插
- 🍁在链表的尾部插入结点，分两种情况：链表为空，链表不为空
- 🍁链表为空：直接将first，last指向该结点，该结点既是链表的首结点，又是最后一个结点
- 🍁链表不为空：last的next执行该节点，该节点的pre指向last，更新last位置
- 🍁在结点尾插完后，更新size的长度，进行size++
public void addLast(E e){
ListNode<E> newNode = new ListNode<>(e);
if(first == null){
first = newNode;
last = newNode;
}else {
last.next = newNode;
newNode.pre = last;
last = newNode;
}
size++;
}🍂进行测试：依次尾插入1，2，3，4，打印list
list.addLast(1);
list.addLast(2);
list.addLast(3);
list.addLast(4);
System.out.println(list);🍀打印结果：因为是尾插，所以打印1，2，3，4
🍏在任意位置插入
这里分三种情况讨论：在第一个位置插入，在最后一个位置插入，在其他位置插入
🍂在第一个位置插入：相当于头插，调用addFirst()方法
🍂在最后一个位置插入：相当于尾插，调用addLast()方法
🍂在其他位置插入：看下图解析
public boolean addIndex(int index,E e){
ListNode<E> newNode = new ListNode<>(e);
if(index < 0 && index > size){
throw new IndexOutOfBoundsException("addIndex：下标越界");
}
if(index == size){
addLast(e);
}else if(index == 0){
addFirst(e);
}else {
ListNode<E> cur = first;
for(int i = 0;i < index;i++){
cur = cur.next;
}
newNode.pre = cur.pre;
newNode.next = cur;
newNode.pre.next = newNode;
cur.pre = newNode;
size++;
}
return true;
}🍂进行测试：原来链表为1，2，3，4，在位置0插入1，在位置5插入5，在位置3插入3
list.addIndex(0,1);
list.addIndex(4,5);
list.addIndex(3,3);
System.out.println(list);🍀打印结果：打印为1，1，2，3，3，4，5
🍑删除remove
这里分为三种情况：删除的是第一个元素，删除的是最后一个元素，删除其他元素
- 🍃删除一个元素：将first指向first的next，再将first的pre指向null
- 🍃删除最后一个元素：将last更新为last的pre位置，再将last的next指向null
🍃删除其他位置元素：参照下图解析
🍃删除完后，进行size--操作
public void remove(E e){
ListNode<E> cur = first;
while(cur != null){
if(e.equals(cur.val)){
break;
}
cur = cur.next;
}
if(cur == first){
first = first.next;
first.pre = null;
}else if(cur == last){
last = last.pre;
last.next = null;
}else {
cur.pre.next = cur.next;
cur.next.pre = cur.pre;
}
size--;
}🍂进行测试：原链表为1，2，3，4，5，删除1，删除5，删除3
list.remove(1);
list.remove(5);
list.remove(3);
System.out.println(list);🍀打印结果：打印2，4
🍒删除removeAll
这个与删除一次出现元素e的做法差不多，只是在找到第一次出现元素e时，将它删掉，继续遍历链表
public void removeAll(E e){
ListNode<E> cur = first;
while(cur != null){
if(cur.val.equals(e)){
if(cur == first){
first = first.next;
first.pre = null;
}else if(cur == last){
last = last.pre;
last.next = null;
}else {
cur.pre.next = cur.next;
cur.next.pre = cur.pre;
}
size--;
}
cur = cur.next;
}
}🍂进行测试：链表为1，2，1，3，1，将所有的1全部删掉
list.removeAll(1);
System.out.println(list);🍀打印结果：链表中的元素只剩下2，3
找元素下标indexOf
创建一个下标index，从0开始增加，每遍历一个元素进行index++，如果遍历的元素是要找的元素则返回index，当遍历完链表没有要找的元素时，返回-1
public int indexOf(E e){
ListNode<E> cur = first;
int index = 0;
while(cur != null){
if(e.equals(cur.val)){
return index;
}else {
index++;
cur = cur.next;
}
}
return -1;
}🍂进行测试：链表为1，2，3，4，5，找3的位置和6的位置
System.out.println(list.indexOf(3));
System.out.println(list.indexOf(6));🍀打印结果：3在下标为2的位置，6不在该链表中，故返回-1
🍍找元素下标lastIndexOf
这个从链表尾部往前遍历，创建index值为size-1，当元素不为我们要找的元素时，index--，找到返回index，当遍历完整个链表都没有找到时，返回-1
public int lastIndexOf(E e){
ListNode<E> cur = last;
int index = size-1;
while(cur != null){
if(e.equals(cur.val)){
return index;
}else {
cur = cur.pre;
index--;
}
}
return -1;
}🍂进行测试：链表为1，2，3，3，4，5，找3的位置和6的位置
System.out.println(list.lastIndexOf(3));
System.out.println(list.lastIndexOf(6));🍀打印结果：最后一个3的下标为3，6不在该链表中
🍅判断链表是否包含某个元素
这里可以调用indexOf方法，看返回的是不是-1，如果不是-1则说明链表包含该元素，如果返回的是-1，说明链表不包含该元素
public boolean contains(E e){
return -1 != indexOf(e);
}🍂进行测试：链表为1，2，3，4，5，判断该链表是否包含2和6
boolean ret = list.contains(2);
boolean ret1 = list.contains(6);
System.out.println(ret);
System.out.println(ret1);🍀输出结果：2在链表中，6不在链表中
获得链表长度
直接返回size即可
public int size(){
return size;
}🍂进行测试：返回空链表的size，和有元素的size
list.clear();
System.out.println(list.size());
list.addFirst(1);
System.out.println(list.size());🍀打印结果：
链表判空
判断链表为空有两种方式：判断size是否为0或者判断first是否指向null
public boolean isEmpty(){
//return size==0;
return first==null;
}🍂进行测试：看有元素的链表是否为空，和空链表是否为空
list.clear();
list.addFirst(1);
boolean ret1 = list.isEmpty();
System.out.println(ret1);
list.clear();
boolean ret2 = list.isEmpty();
System.out.println(ret2);🍀打印结果：
清空链表
清空操作就是将first指向null，将last指向null，将size置0
public void clear(){
first = null;
last = null;
size = 0;
}🍂进行测试：执行清空操作，打印list
list.clear();
System.out.println(list);🍀打印结果：链表中没有元素
到此这篇关于Java中LinkedList的模拟实现的文章就介绍到这了,更多相关Java中 LinkedList的模拟内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
本篇文章主要介绍了Spring中Bean的加载的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-04-04
这篇文章主要为大家详细介绍了servlet实现文件上传、预览、下载、删除功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2017-09-09
这篇文章主要介绍了SpringBoot生产环境和测试环境配置分离的教程详解,需要的朋友可以参考下2020-08-08
这篇文章主要介绍了Java如何Mock FileInputStream问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2023-09-09
这篇文章主要介绍了redis 获取 list 中的所有元素操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-03-03
这篇文章主要给大家介绍了关于java正则表达式对特殊字符的转义以及异常现象的相关资料,在Java中使用正则表达式匹配特殊字符也需要使用转义字符"\",需要的朋友可以参考下2023-06-06
树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构，很象自然界中的树那样。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树形象表示2021-10-10
在Java项目，庞大的对象依赖关系将一直紧密耦合引起对象难以管理或修改。在这种情况下，可以使用Spring框架作为一个核心模块轻松高效地管理所有的对象依赖。本文章向大家介绍Spring松耦合的实例，需要的朋友可以参考一下。2016-12-12
这篇文章主要给大家介绍了关于Java中双冒号(::)运算操作符用法的相关资料,双冒号运算操作符是类方法的句柄,lambda表达式的一种简写,这种简写的学名叫eta-conversion或者叫η-conversion,需要的朋友可以参考下2023-11-11
本篇文章介绍了，JDK环境变量配置的具体操作步骤。需要的朋友参考下2013-05-05
最新评论