Java——LinkedList

1、链表

1.1 链表的概念及结构

链表在逻辑层面上是连续的,在物理层面上不一定是连续的

链表结构可分为,单向或双向、带头或不带头、循环或非循环,组合共计8种

重点:无头单向非循环链表、无头双向链表

1.2 模拟实现无头单向非循环链表

一个链表由若干节点组成,结合 内部类 知识,可将节点类定义在链表类中,成为内部类

java 复制代码
public class MySingleLinkedList {

    static class ListNode {//该内部类中定义的是节点的属性
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;//链表的头节点,定义在MySingleLinkedList类中
    
}

下面以穷举的方式创建链表方便理解(真正创建链表并非如此)

java 复制代码
//MySingleLinkedList类

    //该方法创建一个链表,头节点为node1,当该方法结束后,变量node1...都会销毁,只剩下头节点为head的链表
    public void createdList(){
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        this.head = node1;
    }

打印链表

java 复制代码
//MySingleLinkedList 类

    public void display() {
        ListNode cur = head; //若直接使用head进行遍历打印,将只能打印一次,再次调用该函数,头节点就不在原来的位置了
        while(cur != null) { //注意!此处若写成 cur.next != null 则不会打印最后一个节点
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }

求链表长度:

java 复制代码
    //遍历即可
    public int size() {
        ListNode cur = head;
        int count = 0;
        while(cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

头插法:

java 复制代码
    public void addFirst(int data) {
        ListNode newNode = new ListNode(data);
        newNode.next = head;
        head = newNode;
    }

尾插法:

java 复制代码
    public void addLast(int data) {
        ListNode newNode = new ListNode(data);
        //不要忘记:判空!
        if(head == null) {
            head = newNode;
            return;
        }
        ListNode cur = head;
        while(cur.next != null) { //此处若写成 cur.next != null 则不会打印最后一个节点
            cur = cur.next;
        }
        cur.next = newNode;
    }

在index位置插入

java 复制代码
// IndexNotLegalException 异常类
public class IndexNotLegalException extends RuntimeException{
    public IndexNotLegalException() {

    }
    public IndexNotLegalException(String msg) {
        super(msg);
    }
}


// MySingleLinkedList 类
    public void addIndex(int index, int data) {
        //1、判断index合法性
        try{
            checkIndex(index);
        }catch(IndexNotLegalException e) {
            e.printStackTrace();
        }
        //2、index == 0 || index == size()
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        //3、找到index的前一个位置
        ListNode cur = findIndexSubOne(index);
        //4、进行连接
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
    }
    private void checkIndex(int index) throws IndexNotLegalException{
        if(index < 0 || index > size()) {
            throw new IndexNotLegalException("index不合法!");
        }
    }
    private ListNode findIndexSubOne(int index) {
        int count = 0;
        ListNode cur = head;
        while(count < index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

查找关键字key是否包含在链表中

java 复制代码
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null) {
            if(cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

删除第一次出现关键字key的节点

java 复制代码
    public void remove(int key) {
        //判空
        if(head == null) {
            return;
        }
        //若头节点为key
        while(head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = head;
        //遍历找到值为key的节点
        while(cur.next != null) {
            if(cur.next.val == key) {
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
        System.out.println("没有找到要删除的数字!");
    }

删除所有值为key的节点

java 复制代码
    public void removeAllKey(int key) {
        //判空
        if (this.head == null) {
            return;
        }
        //快慢指针
        ListNode prev = head;
        ListNode cur = head.next;
        while(cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
            }else {
                prev = cur;
            }
            cur = cur.next;
        }
        //处理头节点,当上述操作完成后,只剩下头节点没有判断
        //该方法优于一上来就判断头节点
        if(head.val == key) {
            head =head.next;
        }
    }

清空链表

java 复制代码
    public void clear() {
        ListNode cur = head;
        while(cur != null) {
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

1.3 模拟实现无头双向非循环链表

java 复制代码
public class MyLinkedList {
    static class ListNode {
        public int data;
        public ListNode prev;//前驱节点
        public ListNode next;//后继节点

        public ListNode(int data){
            this.data = data;
        }
    }

    public ListNode head;//头节点
    public ListNode last;//尾节点

    //得到单链表的长度
    public int size(){
        int count = 0;
        ListNode cur = head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur = head;
        while(cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //头插法
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = last = node;
        }else {
            head.prev = node;
            node.next = head;
            head = node;
        }
    }
    //尾插法
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = last = node;
        }else {
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        try{
            checkIndex(index);
        }catch(IndexIllegalException e) {
            e.printStackTrace();
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }
    private ListNode findIndex(int index) {
        ListNode cur = head;
        while(index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
    private void checkIndex(int index) throws IndexIllegalException{
        if(index < 0 || index > size()) {
            throw new IndexIllegalException("双向链表index不合法!");
        }
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                if(cur == head) {
                    head = head.next;
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else if(cur == last) {
                    cur.prev.next = null;
                    last = cur.prev;
                }else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                }
                return;

            }
            cur = cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                if(cur == head) {
                    head = head.next;
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else if(cur == last) {
                    cur.prev.next = null;
                    last = cur.prev;
                }else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                }
            }
            cur = cur.next;
        }
    }

    public void clear(){
        ListNode cur = head.next;
        while(cur != null) {
            cur = head.next;
            head.prev = null;
            head.next = null;
            head = cur;
        }
        head = last = null;
    }
}

链表遍历方式:

java 复制代码
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        //直接sout打印
        System.out.println(list);
        System.out.println("======");

        //foreatch循环打印
        for(Integer x : list) {
            System.out.print(x + " ");
        }
        System.out.println();
        System.out.println("======");

        //for循环打印
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        System.out.println("======");

        //Iterator打印
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
        System.out.println("======");

        //ListIterator可以倒着打印
        ListIterator<Integer> it3 = list.listIterator(list.size());
        while(it3.hasPrevious()) {
            System.out.print(it3.previous() + " ");
        }
    }

运行结果:

2、ArrayList 和 LinkedList 的区别

|-------|---------------|----------------|
| 不同点 | ArrayList | LinkedList |
| 存储空间上 | 逻辑&物理均连续 | 逻辑上连续,物理上不一定连续 |
| 随机访问 | 支持,时间复杂度为O(1) | 不支持,时间复杂度为O(N) |
| 头插 | 需要搬运元素,O(N) | 只需修改引用的指向,O(1) |
| 插入 | 空间不够时需要扩容 | 没有容量概念 |
| 应用场景 | 元素高效存储+频繁访问 | 频繁在任意位置插入删除操作 |

相关推荐
qianbo_insist1 分钟前
c++ python 共享内存
开发语言·c++·python
今天背单词了吗98015 分钟前
算法学习笔记:8.Bellman-Ford 算法——从原理到实战,涵盖 LeetCode 与考研 408 例题
java·开发语言·后端·算法·最短路径问题
天天摸鱼的java工程师18 分钟前
使用 Spring Boot 整合高德地图实现路线规划功能
java·后端
CoderPractice21 分钟前
C#控制台小项目-飞行棋
开发语言·c#·小游戏·飞行棋
Coding小公仔29 分钟前
LeetCode 151. 反转字符串中的单词
开发语言·c++·算法
程序猿阿伟31 分钟前
《声音的变形记:Web Audio API的实时特效法则》
开发语言·前端·php
东阳马生架构33 分钟前
订单初版—2.生单链路中的技术问题说明文档
java
咖啡啡不加糖1 小时前
暴力破解漏洞与命令执行漏洞
java·后端·web安全
风象南1 小时前
SpringBoot敏感配置项加密与解密实战
java·spring boot·后端
DKPT1 小时前
Java享元模式实现方式与应用场景分析
java·笔记·学习·设计模式·享元模式