【3.Linked List与链表】

最新推荐文章于 2024-10-12 16:00:00 发布
最新推荐文章于 2024-10-12 16:00:00 发布
阅读量81 收藏
点赞数
文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A__Plankton_/article/details/131074166
版权
文章介绍了LinkedList作为Java中的数据结构，它基于双向链表实现，不支持随机访问但提供高效插入和删除操作。内容包括LinkedList的基本操作如添加、删除元素，判断链表是否有环，查找链表中间节点等，并对比了ArrayList的特点。
摘要由CSDN通过智能技术生成

LinkedList 简介

在这里插入图片描述

  1. LinkedList实现了List接口
  2. LinkedList的底层使用了双向链表
  3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
  4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
  5. LinkedList比较适合任意位置插入的场景

单向链表的实现与相关OJ题目

package MySingLeList;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class MySingleList {
    //实现单项链表
    class ListNode {
        public int val;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head; //代表当前链表的头节点
    public ListNode creatLink() {
        ListNode listNode0 = new ListNode(3);
        ListNode listNode1 = new ListNode(5);
        ListNode listNode2 = new ListNode(3);
        //ListNode listNode3 = new ListNode(4);
        //ListNode listNode4 = new ListNode(5);
        //ListNode listNode5 = new ListNode(2);
//        ListNode listNode6 = new ListNode(22);
//        ListNode listNode7 = new ListNode(22);
//        ListNode listNode8 = new ListNode(22);
//        ListNode listNode9 = new ListNode(100);
        listNode0.next = listNode1;
        listNode1.next = listNode2;
        //listNode2.next = listNode3;
        //listNode3.next = listNode4;
        //listNode4.next = listNode5;
//        listNode5.next = listNode6;
//        listNode6.next = listNode7;
//        listNode7.next = listNode8;
//        listNode8.next = listNode9;
        head = listNode0;
        return head;
    } //创建链表
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    } //打印链表
    public void display(ListNode newHead) {
        ListNode cur = newHead;
        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;
    } //判断是否存在key值
    public int size(ListNode head) {
        ListNode cur = head;
        int cnt = 0;
        while (cur != null) {
            cnt++;
            cur = cur.next;
        }
        return cnt;
    } //判断链表长度
    public int size() {
        ListNode cur = head;
        int cnt = 0;
        while (cur != null) {
            cnt++;
            cur = cur.next;
        }
        return cnt;
    }
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int la = size(headA);
        int lb = size(headB);
        int len = la - lb;
        if (len > 0){
            while (len >0) {
                headA = headA.next;
                len--;
            }
        } else {
            while (len < 0){
                headB = headB.next;
                len++;
            }
        }
        while (headA != headB) {
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    } // 返回链表相交节点
    public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if( fast == slow ) {
                return true;
            }
        }
        return false;
    } //快慢指针判断链表是否有环
    public void addFirst(int data) {
        ListNode newHead = new ListNode(data);
        newHead.next = head;
        head = newHead;
    }//头插法插入数据
    public void addLast(int data) {
        ListNode newListNode = new ListNode(data);
        ListNode cur = head;
        if(head == null) {
            head = newListNode;
            return;
        }
        while (cur.next != null){
            cur = cur.next;
        }
        cur.next = newListNode;
    } //尾插法插入数据
    public void addIndex(int index,int data) throws CheckIndexExeption{
        ListNode newListNode = new ListNode(data);
        checkIndex(index);
        if(index == 0) {
            addFirst(data);
            return;
        }
        if (index == this.size()) {
            addLast(data);
            return;
        }
        try{
            ListNode cur = findIndexSunOne(index);
            newListNode.next = cur.next;
            cur.next = newListNode;
        } catch (CheckIndexExeption e){
            System.out.println("寄");
        }
    } //下标插入法
    public void remove(int key){
        ListNode cur = head;
        if (head == null) {
            return;
        }
        if(head.val == key) {
            head = head.next;
            return;
        }
        while (cur.next != null) {
            if (cur.next.val == key) {
                cur.next = cur.next.next; // 是这样的

                return;
            }
            cur = cur.next;

        }
        System.out.println("没找到捏");

    } // 删除第一次出现的key
    public void removeAllKeyN2(int key){
        ListNode cur = head;
        while (cur != null){
            if(cur.val == key){
                remove(key);
            }
            cur = cur.next;
        }
    } //删除所有的key   这个方法时间复杂度 为 O（N^2）
    public static ListNode reverseList(ListNode head){
        if(head == null){
            return null;
        }
        if (head.next == null){
            return head;
        }
        ListNode cur = head.next;
        head.next = null;
        while (cur != null){
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    } //链表的反转
    public ListNode middleNode(ListNode head) {
        ListNode cur = head;
        ListNode cur2 = head;
        int cnt = 0;
        int cnt2 = 0;
        while (cur != null) {
            cnt++;
            cur = cur.next;
        }
        //从(cnt/2)+1开始返回
        int mid = (cnt/2)+1;
        while (cur2 != null) {
            if(cnt2 == mid) {
             head = cur2;
            }
            cnt2++;
            cur2 = cur2.next;
        }
        return head;
    }//链表的中间节点 常规解法
    public ListNode middleNode2(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    } //链表中间节点 快慢指针
    public int kthToLast(ListNode head, int k) {
        ListNode slow = head;
        ListNode fast = head;
        for (int i = 0; i < k-1; i++) {
            fast = fast.next;
        }
        while (fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow.val;
    } //快慢指针 返回倒数第k个值
    public ListNode mergeTwoLists(ListNode head1, ListNode head2) {
        ListNode newhead = new ListNode(0);
        ListNode temp = newhead;
        while (head1 != null && head2 != null) {
            if (head1.val < head2.val) {
                temp.next = head1;
                head1 = head1.next;
                temp = temp.next;

            } else {
                temp.next = head2;
                head2 = head2.next;
                temp = temp.next;
            }
        }
        if (head1 != null) {
            temp.next = head1;
        }
        if (head2 != null) {
            temp.next = head2;
        }
        return newhead.next;
    } // 合并两个有序列表
    public boolean isPalindrome(ListNode head) {
        if(head == null) {
            return false;
        }
        if(head.next == null) {
            return true;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode cur = slow.next;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        while (slow != head) {
            if(head.val != slow.val) {
                return false;
            }
            if(head.next == slow) {
                return true;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;

    } //判断回文链表
    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;
        }
    }  //删除所有的key   这个方法时间复杂度 为 O（N）
    public void clear() {
        head = null;
    }// 清空链表
    public ListNode partition(ListNode head, int x) {
        ListNode cur = head;
        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;
        while (cur != null){
            if(cur.val < x) {
                if(bs == null) {
                    bs = cur;
                    be = cur;

                } else {
                    be.next = cur;
                    be = be.next;

                }
            } else {
                if(as == null) {
                    as = cur;
                    ae = cur;

                } else {
                    ae.next = cur;
                    ae = ae.next;

                }
            }
            cur = cur.next;
        }
        if( bs == null) {
            return as;
        }
        be.next = as;
        if( as != null){
            ae.next = null;
        }
        return bs;

    } //分割链表
    private ListNode findIndexSunOne(int index) {
        ListNode cur = head;
        int cnt = 0;
        while (cnt != index-1) {
            cur = cur.next;
            cnt++;
        }
        return cur;
    }
    public ListNode reverseBetween (ListNode head, int m, int n) {
        if(head == null){
            return null;
        }
        if(head.next == null || (m == 1 && n == 1)){
            return head;
        }
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode cur = dummyHead;
        while (m - 1 > 0){
            cur = cur.next;
            m--;
        }
        ListNode prev = cur;
        cur = dummyHead;
        while (n  > 0){
            cur = cur.next;
            n--;
        }
        ListNode right = cur;
        ListNode last = right.next;
        ListNode h1 = prev.next;
        ListNode h2 = prev.next;
        prev.next = null;
        right.next = null;
        prev.next = reverseList(h1);
        h2.next = last;
        return head;
    } //指定区间反转链表
    /*
public Node copyRandomList(Node head) {
        Map<Node,Node> map = new HashMap<>();
        Node cur = head;
        while (cur != null){
            Node node = new Node(cur.val);
            map.put(cur,node);
            cur = cur.next;
        }
        Node cur1 = head;
        while (cur1 != null){
            map.get(cur1).next = map.get(cur1.next);
            map.get(cur1).random = map.get(cur1.random);
            cur1 = cur1.next;
        }
        return map.get(head);
    }
 */ // 复制带随机指针的链表
    private void checkIndex(int index) throws CheckIndexExeption{
        if(index<0 || index>this.size()){
            throw new CheckIndexExeption("下标不合法");
        }
    }
}

LinkedList 的实现

package MyLinkedList;
//双向链表的实现
public class myLinkedList {
    public ListNode head;
    public ListNode last;
    static class ListNode{
        public int val;
        public ListNode prev;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }
    public void creatList() {
        ListNode node1 = new ListNode(8);
        ListNode node2 = new ListNode(9);
        ListNode node3 = new ListNode(55);
        ListNode node4 = new ListNode(78);
        ListNode node5 = new ListNode(96);
        ListNode node6 = new ListNode(3);
        ListNode node7 = new ListNode(20);
        ListNode node8 = new ListNode(100);

    }
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
    public int size() {
        ListNode cur = head;
        int cnt = 0;
        while (cur != null) {
            cnt ++;
            cur = cur.next;
        }
        return cnt;
    }
    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;
        } else {
            node.next = head;
            head.prev = node;
            head = node;
        }

    }
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if(head == null){
            last = node;
            head = node;
        } else {
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
    public void addIndex(int index, int data) {
        if (index<-1 || index>size()){
            System.out.println("寄");
            return;
        }
        if ( index == 0 ) {
            addFirst(data);
            return;
        }
        if (index == size() ) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = head;
        while (index > 0){
            cur = cur.next;
            index--;
        }
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;


    }
    public void remove(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 {
                    cur.prev.next = cur.next;
                    if (cur.next != null){
                        cur.next.prev = cur.prev;
                    } else {
                        last = last.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }
    public void removeAll(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 {
                    cur.prev.next = cur.next;
                    if (cur.next != null){
                        cur.next.prev = cur.prev;
                    } else {
                        last = last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    public void clear(){
        ListNode cur = head;
        while (cur != null){
            ListNode curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
    }


}

ArrayList与LinkedList的区别

在这里插入图片描述

栗悟饭与龟波功Christ
关注
C++链表（linked list）
qq_31617961的博客
08-31 2150
基础知识 链表也是一种线性表。链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。 插入、删除数据效率O(1)级别（只需更改指针指向即可），随机访问效率O(n)级别（需要从链头至链尾进行遍历）。此外和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储指针。 常用链表： 单链表：每个节点只包含一个指针，即后继指针。首节点地址表示整条链表，尾节点的后继指针指向空地址null 循环链表：除了尾节点的后继指针指向首节点的...
Java/206. Reverse Linked List 反转链表
qq_38959715的博客
11-04 728
题目       代码部分一（0ms 迭代） class Solution { public ListNode reverseList(ListNode head) { if(head == null || head.next == null) return head; ListNode node, temp; ...
Java/234. Palindrome Linked List 回文链表
qq_38959715的博客
07-18 1572
题目 代码部分（3ms 58.27%） /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Sol...
02-链表结构（Linked list）
其木王·王子的博客
03-09 3611
链表1.五花八门的链表结构1.1 底层的存储结构1.2 三种最常见的链表结构1.2.1 单链表1.2.1 单链表的查找、插入、删除1.2.2 循环链表1.2.3 双向链表1.2.3.1 双向链表删除操作1.2.4 双向循环链表2. 链表 VS 数组性能大比拼3. 如何基于链表实现 LRU 缓存淘汰算法？ 1.五花八门的链表结构 相比数组，链表是一种稍微复杂一点的数据结构。这两个非常基础、非常常用的数据结构，我们常常会放到一块儿来比较。所以我们先来看，这两者有什么区别。 1.1 底层的存储结构 我们先从底层的
链表Linked List
weixin_63145469的博客
12-06 1443
链表的动态的创建与删除
【LeetCode】141. Linked List Cycle(Java)
Rabbit_Judy的博客
02-27 352
题目描述：给定一个链表，确定其中是否有一个循环。 为了表示给定链表中的循环，我们使用一个整数pos，它表示tail连接到的链表中的位置(0-index)。如果pos为-1，则链表中没有循环。 Example 1: Input: head = [3,2,0,-4], pos = 1 Output: true ** * 判断链表是否有环 * * @author wangfei */ publ...
382. Linked List Random Node
cuihaolong的专栏
08-17 727
题目 Given a singly linked list, return a random node's value from the linked list. Each node must have the same probability of being chosen. Follow up: What if the linked list is extremely lar
leetcode 142. Linked List Cycle II
chaideyipi
07-16 1673
Given a linked list, return the node where the cycle begins. If there is no cycle, return null. Note: Do not modify the linked list. Follow up: Can you solve it without using extra space? 题目要求不修改链表...
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
Leetcode 206. Reverse Linked List 链表翻转 Python 两种解法
小鹅鹅的博客
03-15 1676
问题描述 Reverse a singly linked list. 翻转一个链表 #1 第一种方法：迭代 class ListNode(object): def __init__(self, x): self.val = x self.next = None class Solution(object): def reverseList...
danlianbiao.rar_Linked list_链表
09-23
与数组不同，链表的元素不需要在内存中连续存储，因此插入和删除操作通常比数组更快。 在这个项目中，首先会创建一个链表节点类（LinkedListNode），用于表示链表中的每一个元素。这个类通常包含两个字段：`Data`...
C_linked_list_data.zip_C语言 链表_链表
09-22
链表是一种重要的数据结构，在计算机科学中被广泛用于组织和管理数据。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过指针连接一系列节点，每个节点包含数据和指向下一个节点的指针。这种数据结构...
基于python的.Linked-List-Basic.md
07-23
**双向链表（DoublyLinkedList）** 是一种特殊类型的链表，每个节点有两个指针，一个指向前一个节点，另一个指向后一个节点。这种结构使得双向链表可以在两个方向上进行遍历。 - **特点**： - 能够方便地访问当前...
Java链表（Linked List）基本原理与实现方法入门示例
08-19
Java链表（Linked List）基本原理与实现方法入门示例 Java链表（Linked List）是一种基础而且重要的数据结构，在Java程序设计中广泛应用。本文将对Java链表（Linked List）的基本原理与实现方法进行详细介绍，并...
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 280
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
数据结构：双向带头链表
qq_71391318的博客
10-12 541
双向带头链表简易代码
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 694
数据结构编程实践20讲(Python版)—09B树
数据结构——双向链表
最新发布
2401_82924480的博客
10-12 420
C语言实现的双向链表
【关系模型】关系数据结构、基本关系代数运算
lin_miao_2023的博客
10-07 749
昨天补充了DBMS概况的存储管理层面，今天来详细介绍数据库管理系统中常见且应用广泛的关系型数据库（简称关系数据库），比如postgreSQL、MySQL、Oracle Database。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值