[Collection与数据结构] 链表与LinkedList(四):双向无头非循环链表的实现与LinkedList的使用

已于 2024-04-15 21:32:22 修改
阅读量1.4k 收藏 12
点赞数 25
分类专栏： Collection与数据结构 文章标签： 数据结构 链表 java
于 2024-04-02 13:20:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80050796/article/details/137263738
版权

1. 双向无头非循环链表的实现

在这里插入图片描述
下面我们给出一个接口,接口中的这些方法就是待实现的方法

public interface ILinkedList_2 {
        //头插法
      void addFirst(int data);
        //尾插法
      void addLast(int data);
        //任意位置插入,第一个数据节点为0号下标
      void addIndex(int index,int data);
        //查找是否包含关键字key是否在单链表当中
      boolean contains(int key);
        //删除第一次出现关键字为key的节点
      void remove(int key);
        //删除所有值为key的节点
      void removeAllKey(int key);
        //得到单链表的长度
      int size();
      void display();
      void clear();
    }

下面实现这些方法:

/**
 * 双向链表的实现
 */
public class MyLinkedList_2 implements ILinkedList_2 {
    class ListNode{
        public ListNode pre;//比单向链表多出来的地方,和前一个结点也是连起来的
        public ListNode next;
        public int val;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last;//有末结点

    /**
     * 头插法
     * @param data
     */
    @Override
    public void addFirst(int data) {
        ListNode listNode = new ListNode(data);
        if (head == null){//注意为空的情况
            head = listNode;
            last = listNode;
        }else{//注意加上else,否则在一开始的时候,listnode.next为head,next就会被置为head
            //就会永远在头结点处死循环
            listNode.next = head;
            head.pre = listNode;
            head = listNode;
        }
    }

    /**
     * 尾插法
     * @param data
     */
    @Override
    public void addLast(int data) {
        ListNode listNode = new ListNode(data);
        if (head == null){
            head = listNode;
            last = listNode;
        }else {
            listNode.pre = last;
            last.next = listNode;
            last = last.next;
        }
    }

    private boolean checkIndex(int index){//检查index是否合法
        if (index > size() ||index < 0){
            return false;
        }
        return true;
    }
    private ListNode findNode(int index) {//找到对应下标的结点
        ListNode cur = head;
        int count = 0;
        while (count != index){
            count ++;
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 在指定位置插入结点
     * @param index
     * @param data
     */
    @Override
    public void addIndex(int index, int data) {
        if (!checkIndex(index)){
            throw new IndexExecption("下标输入有误");
        }
        if (index == 0){
            addFirst(data);
            return;//记得返回,不然下面的代码也会执行
        }
        if (index == size()){
            addLast(data);
            return;
        }
        ListNode listNode = new ListNode(data);
        ListNode cur = findNode(index);
        listNode.next = cur;
        listNode.pre = cur.pre;
        cur.pre.next = listNode;
        cur.pre = listNode;

    }

    /**
     * 查看链表中是否包含指定元素
     * @param key
     * @return
     */
    @Override
    public boolean contains(int key) {
        if (head == null){
            return false;
        }
        ListNode cur = head;
        while (cur != null){//先遍历链表
            if (cur.val == key){
                return true;//找到相等的值直接返回true
            }
            cur = cur.next;
        }
        return false;//跳出来就证明已经走到了终点,没找到
    }

    /**
     * 删除第一个值为key的结点
     * @param key
     */
    @Override
    public void remove(int key) {
        ListNode cur = head;
        while(cur != null){//cur向下遍历
            if (cur.val == key){//cur找到的清空
                if (cur == head){//如果cur为头结点
                    head = head.next;//head向后移动
                    if (head != null){
                        head.pre = null;
                    }else {//如果cur为头结点且只有一个结点
                        last = null;//last也置为空
                    }
                }else {//cur不为头结点
                    if (cur.next != null){//cur为中间结点
                        cur.pre.next = cur.next;
                        cur.next.pre = cur.pre;
                    }else {//cur为尾结点
                        cur.pre.next = null;
                        last = last.pre;
                    }
                }
                return;//删完返回
            }
            cur = cur.next;//cur向下走
        }
    }

    /**
     * 删除所有值为key结点
     * @param key
     */
    @Override
    public void removeAllKey(int key) {
        ListNode cur = head;
        while(cur != null){//cur向下遍历
            if (cur.val == key){//cur找到的清空
                if (cur == head){//如果cur为头结点
                    head = head.next;//head向后移动
                    if (head != null){
                        head.pre = null;
                    }else {//如果cur为头结点且只有一个结点
                        last = null;//last也置为空
                    }
                }else {//cur不为头结点
                    if (cur.next != null){//cur为中间结点
                        cur.pre.next = cur.next;
                        cur.next.pre = cur.pre;
                    }else {//cur为尾结点
                        cur.pre.next = null;
                        last = last.pre;
                    }
                }//直接把return去掉,删完不返回,继续删
            }
            cur = cur.next;//cur向下走
        }
    }

    /**
     * 计算链表大小
     * @return
     */
    @Override
    public int size() {
        int count = 0;
        ListNode cur = head;
        while (cur != null){
            cur = cur.next;
            count++;
        }
        return count;
    }

    /**
     * 打印链表
     */
    @Override
    public void display() {
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

    /**
     * 清空链表
     */
    @Override
    public void clear() {
        ListNode cur = head;
        while (cur != null){
            ListNode curNext = cur.next;//记录下一个结点
            cur.next = null;
            cur.pre = null;//每一个结点的next和pre都置空
            cur = curNext;
        }
        head = null;
        last = null;//head和last指向的仍然是原来的地址,cur只是修改了节点内的值,
        //所以head和last需要手动置空
    }
}

[注意事项]

  1. 在头插法和尾插法的过程中,如果该链表为空,在把该链表的头结点和尾结点都指向添加结点之后,记得后面不符合条件的语句用else括起来,否者在头插或尾插之后,还会执行head!=null的代码
  2. 在中间插入节点的时候,如果插入的结点为头插或者是尾插的时候,记得返回,否者和上面的一条一样,执行完头插和尾插之后,又会执行中间插入的代码.
  3. 删除代码的逻辑较为复杂,我们通过一张图来表示
    在这里插入图片描述
    测试上面实现的方法:
/**
 * 开始测试
 */
public class Test {
    public static void main(String[] args) {
        MyLinkedList_2 myLinkedList_2 = new MyLinkedList_2();
        myLinkedList_2.addFirst(1);
        myLinkedList_2.addFirst(2);
        myLinkedList_2.addFirst(3);
        myLinkedList_2.addFirst(4);
        myLinkedList_2.display();
        MyLinkedList_2 myLinkedList_21 = new MyLinkedList_2();
        myLinkedList_21.addLast(1);
        myLinkedList_21.addLast(2);
        myLinkedList_21.addLast(3);
        myLinkedList_21.addLast(4);
        myLinkedList_21.display();
        myLinkedList_21.addIndex(1,34);
        myLinkedList_21.addIndex(2,45);
        myLinkedList_21.display();
        MyLinkedList_2 myLinkedList_22 = new MyLinkedList_2();
        myLinkedList_22.addIndex(0,1);
        myLinkedList_22.addIndex(1,2);
        myLinkedList_22.addIndex(2,3);
        myLinkedList_22.display();
        System.out.println(myLinkedList_22.contains(2));
        System.out.println(myLinkedList_22.contains(4));
        myLinkedList_21.remove(2);
        myLinkedList_21.display();
        MyLinkedList_2 myLinkedList_23 = new MyLinkedList_2();
        MyLinkedList_2 myLinkedList_24 = new MyLinkedList_2();
        myLinkedList_23.addFirst(1);
        myLinkedList_23.remove(1);
        myLinkedList_23.display();
        myLinkedList_24.remove(1);
        MyLinkedList_2 myLinkedList_25 = new MyLinkedList_2();
        myLinkedList_25.addFirst(2);
        myLinkedList_25.remove(1);
        MyLinkedList_2 myLinkedList_26 = new MyLinkedList_2();
        myLinkedList_26.addFirst(1);
        myLinkedList_26.addFirst(1);
        myLinkedList_26.addFirst(1);
        myLinkedList_26.addFirst(1);
        myLinkedList_26.addFirst(1);
        myLinkedList_26.addFirst(2);
        myLinkedList_26.removeAllKey(1);
        myLinkedList_26.display();
    }
}

测试结果:

在这里插入图片描述

2. LinkedList的使用

LinkedList的底层是双向无头非循环链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高.

2.1 构造方法

方法说明
public LinkedList()无参构造方法
public LinkedList(Collection<? extends E> c)使用容器中的其他容器来构造,传入的容器中的数据类型必须是E的子类,以便兼容
public class LinkedList1 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        LinkedList<Number> list2 = new LinkedList<>(list1);
    }
}

2.2 常用方法

方法说明
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> 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
public static void main(String[] args) {
	LinkedList<Integer> list = new LinkedList<>();
	list.add(1); // add(elem): 表示尾插
	list.add(2);
	list.add(3);
	list.add(4);
	list.add(5);
	list.add(6);
	list.add(7);
	System.out.println(list.size());
	System.out.println(list);
	// 在起始位置插入0
	list.add(0, 0); // add(index, elem): 在index位置插入元素elem
	System.out.println(list);
	list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
	list.removeFirst(); // removeFirst(): 删除第一个元素
	list.removeLast(); // removeLast(): 删除最后元素
	list.remove(1); // remove(index): 删除index位置的元素
	System.out.println(list);
	// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
	if(!list.contains(1)){
		list.add(0, 1);
	}
	list.add(1);
	System.out.println(list);
	System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
	System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
	int elem = list.get(0); // get(index): 获取指定位置元素
	list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
	System.out.println(list);
	// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
	List<Integer> copy = list.subList(0, 3); 
	System.out.println(list);
	System.out.println(copy);
	list.clear(); // 将list中元素清空
	System.out.println(list.size());
}

2.3 LinkedList的遍历

import java.util.*;

public class LinkedList1 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);//通过sout遍历
        for (int x: list) {//通过for_each遍历
            System.out.print(x+" ");
        }
        ListIterator<Integer> iterator = list.listIterator();
        while (iterator.hasNext()){//通过迭代器向后遍历
            System.out.println(iterator.next());
        }
        ListIterator<Integer> iterator1 = list.listIterator(list.size());
        while (iterator1.hasPrevious()){//通过迭代器向前遍历
            System.out.println(iterator1.previous());
        }
    }
}

面试题 ArrayList与LinkedList的区别
从插入,修改,删除,查找这几方面来说

  1. 插入:顺序表在插入的时候必须把插入点之后的元素全部后移,而链表不需要
  2. 修改:顺序表可以直接根据下标找到要修改的元素,而链表需要遍历
  3. 删除:顺序表删除点之后的元素必须向前移动,而链表不需要
  4. 查找: 顺序表可以直接根据下标查找,而链表需要遍历
LileSily
关注
  • 25
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
【数据结构】链表LinkedList
qq_61862008的博客
11-18 972
链表以及LinkedList介绍
数据结构《LinkeList 双向链表》
m0_66483195的博客
11-13 1046
LinkeList 的模拟和使用
[Collection与数据结构] 链表与LinkedList (一):链表概述与单向无头非循环链表实现
2301_80050796的博客
03-27 1183
上篇文章我们已经对顺序表进行了实现,并且对ArrayList进行了使用,我们知道ArrayList底层是使用数组实现的.由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 1520
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
【Java 数据结构】单向链表和双向链表的实现 (LinkedList)
热门推荐
书生-w的博客
04-16 1万+
​首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2473
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
【数据结构】双向链表的模拟实现（无头）
m0_73067372的博客
02-11 917
单向链表能够解决逻辑关系为"一对一"数据的存储问题，但是在解决某些特殊问题的时候，单链表并不是效率最有的存储结构。比如，需要找某个节点的前驱节点，使用单链表并不合适，单链表更适合"从前往后"找，而"从后往前"找并不是单链表的强项。这里就要使用双向链表来解决这类问题。
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 6487
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
【数据结构】 LinkedList的模拟实现与使用
m0_71731682的博客
08-23 3213
LinkedList 的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。// add(elem): 表示尾插 list . add(2);// 在起始位置插入0 list . add(0 , 0);
Python数据结构与算法之列表（链表，linked list）简单实现
09-21
主要介绍了Python数据结构与算法之列表（链表，linked list）简单实现，具有一定参考价值，需要的朋友可以了解下。
C#双向链表LinkedList排序实现方法
09-03
主要介绍了C#双向链表LinkedList排序实现方法,涉及C#双向链表的定义与排序技巧,具有一定参考借鉴价值,需要的朋友可以参考下
链表+泛型+反射实现自定义的LinkedList集合类
09-11
该资源利用基础的链表结构，结合泛型和反射的知识点，实现重写LinkedList集合类，可以存放任意类型数据。比较推荐对Java有稳固基础的同学来阅读，为了方便阅读，代码的注释写的非常的清楚
多年后，再探算法和数据结构
最新发布
qq_52010229的博客
05-09 182
多年来，通过深入学习和实践各种编程语言，我对数据结构和算法在程序设计中的中心地位有了新的认识。本次从汇编语言到高级编程语言的探讨，展示了无论技术如何进步，构成程序的核心—算法和数据结构—始终保持其基础和不变的角色。
拓扑排序——数据结构
2301_79629384的博客
05-08 187
拓扑排序的本质是这样的：你有一堆任务或者课程，某些任务必须在其他任务之前完成，就像先去健身再去约会，这样你看起来更加帅气迷人。在拓扑排序中，每个任务或者课程都是图中的一个节点，而某个任务依赖另一个任务的关系，就用有向边来表示。就像精心策划一场约会，了解每一步的逻辑和顺序，才能确保一切按部就班，避免任何尴尬的等待或冲突。拓扑排序是对有向无环图（DAG）的顶点进行线性排序的方法。关键在于每个顶点代表了一个任务，而每条有向边代表了任务间的先后依赖关系。这个排序保证了每个任务只在它依赖的任务完成后才开始。
数据结构（一）初识数据结构
无人罪的博客
05-08 239
数据的组织方式要以问题为核心，提高解决问题的效率数据的结构服务于具体的对数据操作（增，删，改，查），考虑数据组织方式就是如何提高数据操作的效率根据数据存储方式划分数据空间，同样的根据数据空间（数据量大小）划分数据存储方式。
数据结构---顺序表
2301_78724721的博客
05-09 682
数据结构是由“数据”和“结构”两词组合⽽来。什么是数据？常⻅的数值1、2、3、4.....、教务系统⾥保存的⽤⼾信息（姓名、性别、年龄、学历等 等）、⽹⻚⾥⾁眼可以看到的信息（⽂字、图⽚、视频等等），这些都是数据 什么是结构？当我们想要使⽤⼤量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独⽴的变量对于程序来说，可读性 ⾮常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的 ⽅式。
相交链表（数据结构）
Jason_from_China的博客
05-08 217
160. 相交链表 - 力扣（LeetCode）
【初阶数据结构】栈
2301_77112794的博客
05-08 747
本文主要介绍了栈的相关知识
循环链表以即使用场景，arraylist 和linkedlist（数据结构上）使用区别
04-05
2. 循环列表：循环链表可以用于实现循环列表，当列表的末尾指向头部时，可以循环遍历列表。 3. 轮流报数：循环链表可以用于实现轮流报数的问题，即每隔n个人就淘汰一个人，最后剩下的人获胜。 ArrayList和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值