java链表实例

已于 2023-04-11 11:21:26 修改
阅读量150 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 链表 数据结构 文章标签： 链表 数据结构 java
于 2023-04-10 17:23:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nihaomeimeiz/article/details/130028954
本文介绍了链表的基本概念，包括单链表、双链表和循环链表，并提供了移除链表元素的三种方法。接着，详细阐述了如何设计链表，包括单链表和双链表的数据结构及操作。此外，还讨论了翻转链表的双指针法和虚拟头指针法，以及两两交换链表节点的技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1 链表基本图解

单链表
在这里插入图片描述
双链表
在这里插入图片描述
循环链表
在这里插入图片描述
存储方式：存储空间不连续，以指针指向存储的位置
在这里插入图片描述
链表优点：删除或者添加节点的时候只需要将指针的指向改变就行，与数组相比复杂度降低了许多。
缺点：遍历寻址浪费时间
在这里插入图片描述

2. 移除链表元素

class Solution {
    public ListNode removeElements(ListNode head, int val) {
      //1 使用虚拟头指针
        if (head == null){
            return head;
        }

        ListNode dummy = new ListNode(-1, head);        //虚拟头节点，防止头节点被删除情况下需要单独操作
        ListNode pre = dummy;
        ListNode cur = head;

        while (cur != null){
            if (cur.val == val){
                pre.next = cur.next;                    //直接将指针指向删除元素下一个就好了
            }
            else{
                pre = cur;                             //不删除的话pre指针跟着cur走就好了
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //2 不添加虚拟节点，但是有pre的方式
        while (head != null && head.val == val){      //注意：需要优先处理head，不然有可能空了但是却没办法判断
            head = head.next;                         //如[7,7,7,7,7]7  先处理完成为空，直接不用执行其他的
        }

        if (head == null){
            return head;
        }

        ListNode pre = head;
        ListNode cur = head.next;

        while (cur != null){
            if (cur.val == val){
                pre.next = cur.next;                    //直接将指针指向删除元素下一个就好了
            }
            else{
                pre = cur;                             //不删除的话pre指针跟着cur走就好了
            }
            cur = cur.next;
        }
        return head;
    }
}

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //3 不使用虚拟头指针
        while(head != null && head.val == val){
            head = head.next;                      //删除头节点的方法就是直接指向后一个就好了
        }
        if (head == null){
            return head;
        }

        ListNode cur = head;

        while (cur != null){
            while (cur.next != null && cur.next.val == val){
                cur.next = cur.next.next;
            }
            cur = cur.next;
        }
        return head;
    }    
}

3. 设计链表

//1 针对单链表来说
class ListNode {
    int val;
    ListNode next;
    ListNode(){}

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


class MyLinkedList {
    int size;       //链表大小
    ListNode head;       //头节点

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }
    
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
       
        ListNode pre = head;
        for (int i = 0; i <= index; i ++) {     //需要包含，因为index和i的索引都是从0开始，一一对应的
                pre = pre.next;
        }
        return pre.val;
    }
    
    public void addAtHead(int val) {
      addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);

    }
    
    public void addAtIndex(int index, int val) {
        
        if (index > size)  return;
        if (index < 0)  index = 0;
                                                     //添加一个值后size增加一
        size ++;                                     //当找到size的时候，对应的指针指向它的前驱节点
        ListNode pred = head;
        for (int i = 0; i < index; i ++){
                pred = pred.next;                     //找到前驱节点
            }

        ListNode newNode = new ListNode(val);
        newNode.next = pred.next;
        pred.next = newNode;  
    }
    
    public void deleteAtIndex(int index) {

        if (index < 0 || index >= size) {
            return;
        }

        size --;                                  //删除一个节点后尺寸size减小一

        if (index == 0){
            head = head.next;
        return;
        }

        ListNode pred = head;

        for (int i = 0; i < index; i ++){
            pred = pred.next;               //找到前驱节点
        }
        pred.next = pred.next.next;
    }
}

//2 双链表
class ListNode {
    int val;
    ListNode next, prev;
    ListNode() {};

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


class MyLinkedList {
    int size;       //链表大小
    ListNode head, tail;       //头节点, 尾节点      

    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
       
        ListNode cur = head;
        if (index >= size / 2) {        //判断从哪一边遍历时间会短一点
            cur = tail;
            for (int i = 0; i < size - index; i ++) {
                cur = cur.prev;
            }
        }
        else{
            for (int i = 0; i <= index; i ++) {
                cur = cur.next;
            }                 
        }
        return cur.val;
    }


    public void addAtHead(int val) {
      addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);

    }
    
    public void addAtIndex(int index, int val) {
        
        if (index > size)  return;
        if (index < 0)  index = 0;
                                                     //添加一个值后size增加一
        size ++;                                     //当找到size的时候，对应的指针指向它的前驱节点
        ListNode pred = head;
        for (int i = 0; i < index; i ++){
                pred = pred.next;                     //找到前驱节点
            }

        ListNode newNode = new ListNode(val);
        newNode.next =  pred.next;                    //需要从后面开始处理，不然会报错
        pred.next.prev = newNode;
        newNode.prev = pred;
        pred.next = newNode; 
    }
    
    public void deleteAtIndex(int index) {

        if (index < 0 || index >= size) {
            return;
        }

        size --;                                  //删除一个节点后尺寸size减小一

        if (index == 0){
            head = head.next;
        return;
        }

        ListNode pred = head;

        for (int i = 0; i < index; i ++){
            pred = pred.next;               //找到前驱节点
        }
        pred.next.next.prev = pred;                //需要从后面开始处理，不然会报错
        pred.next = pred.next.next;
        
    }
}

4. 翻转链表

//1 双指针法
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;       //缓存指针

        while (cur != null) {
            temp = cur.next;        //将指针的指向交换
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
    return pre;
    } 
}
//2 虚拟头指针法
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = head;
        ListNode temp = null;

        while (cur != null) {
            temp = cur.next;        //将指针的指向交换
            cur.next = dummy.next;
            dummy.next = cur;
            cur = temp;
        }
    return dummy.next;
    } 
}
//3 栈方法
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) return null;            //为空
        if (head.next == null) return head;       //只有一个元素

        Stack<ListNode> stack = new Stack<>();    //创建栈
        ListNode cur = head;

        while (cur != null){                        //元素依次入栈
            stack.push(cur);
            cur = cur.next;
        }

        //创建一个虚拟头节点
        ListNode pHead = new ListNode(0);
        cur = pHead;
        while (!stack.isEmpty()) {                      //元素怒依次出栈
            ListNode node = stack.pop();
            cur.next = node;
            cur = cur.next;
        }

        cur.next = null;                            //最后一个元素要为null
        return pHead.next;
    }
}

5. 两两交换链表中的节点

在这里插入图片描述

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1);              //创建虚拟头节点
        dummy.next = head;
        ListNode cur = dummy;
        ListNode temp;              //保存第三个节点
        ListNode firstNode;         //缓存第一个
        ListNode secondNode;        //缓存第二个

        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstNode = cur.next;
            secondNode = cur.next.next;
           
            cur.next = secondNode;                     
            secondNode.next = firstNode;
            firstNode.next = temp;
            cur = firstNode;
        }
        return dummy.next;
    }
}

//2 递归思想
class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null)  return head;

        ListNode next = head.next;
        ListNode swapNode = swapPairs(next.next);     //递归

        next.next = head;                          //交换操作
        head.next = swapNode;

        return next;
     }
}

6. 删除链表中倒数第N个节点

//1 先统计个数，再删除
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        
        ListNode dummy = new ListNode(-1);     //创建虚拟头节点
        dummy.next = head;
        ListNode cur = head;
        int size = 0;                  //统计链表节点个数

        while (cur != null) {
            size ++;
            cur = cur.next;
        }

        ListNode pred = dummy;         
        for (int i = 0; i < size - n; i ++) {     //寻找前驱节点
            pred = pred.next;
        }

        pred.next = pred.next.next;
        return dummy.next;
    }
}
// 2 快慢指针
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode slowPoint = dummy;
        ListNode fastPoint = dummy;

        for (int i = 0; i < n; i ++){
            fastPoint = fastPoint.next;          //使得快慢指针相差n个
        }

        while (fastPoint.next != null) {             //快慢指针同时向后直到最后
            fastPoint = fastPoint.next;            
            slowPoint = slowPoint.next;
        }

        slowPoint.next = slowPoint.next.next;       //此时的slowPoint是前驱节点，执行删除
        return dummy.next;
    }
}

7. 链表相交

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0;   //记录两个链表的长度
        int lenB = 0;
        ListNode preA = headA;
        ListNode preB = headB;

        while (preA != null) {         //获取A的长度
            lenA ++;
            preA = preA.next;
        }

        while (preB != null) {        //获取B的长度
            lenB ++;
            preB = preB.next;
        }

        ListNode curA = headA;                   //指针重新指向头节点
        ListNode curB = headB; 

        if (lenA < lenB) {                                 //让curA指向较长的链表
            int tempLen = lenA;
            lenA = lenB;
            lenB = tempLen;

            ListNode tempNode = curA;
            curA = curB;
            curB = tempNode;
        }

        int gap = lenA - lenB;
        while ( gap > 0) {                         //将curA移动到和curB的开始处对齐
            curA = curA.next; 
            gap --;
        }

        while (curA != null) { 
            if (curA == curB) {                                 //找到值相同的点
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;     
    }

8.环形链表

在这里插入图片描述

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;   

            if (fast == slow) {           //如果有环，快慢指针一定相遇。类似于操场跑步。跑的快的一定会追上慢的
                ListNode node1 = head;
                ListNode node2 = fast;

                while (node1 != node2) {      //都按照一步走就能找到入环处
                    node1 = node1.next;
                    node2 = node2.next;
                }
                return node1;
            } 
            
        }
        return null; 
    }
}
链表实例操作
m0_61643713的博客
12-20 607
链表的实例操作，根据菜单选择相应操作
用Java初始化单链表
Cooks的博客
01-27 6865
--------------------------------------------------链表的创建---------------------------------------------------------- 链表类    ｛ 节点头         链表中的节点类    {         数据域         指针域         构造方法（传入数据）
6.JAVA-链表实例
weixin_30647065的博客
04-29 152
1.实现链表的步骤 1).实现Node节点类(用来保存链表中每个节点的数据,以及下一个节点成员) 2).实现LinkList链表类(用来封装Node节点类,和用户实现交互) 3).在LinkList类里,实现添加,删除,根据要查的Node数据来找表中的序号,根据要查的序号来找对应的Node数据. 4).在LinkList类里,实现toArrays方法,用来取出链表中的Node数据的数...
Java中单链表的实现及一些简单链表题运行案例
qq_45938144的博客
06-05 301
Java中单链表的实现及一些简单链表题运行案例 1.链表类和节点内部类的创建 2.插入节点 3.删除节点 4.获取头节点 5.获取链表长度 6.判断链表是否为空 7.判断链表中某数据是否存在 8.根据索引获取元素 9.用新数据替换指定位置的的数据 10.清空链表 11.获取链表中第k个节点 12.判断两个链表是否相交 13.获取两个相交链表的第一个公共节点 14.判断链表是否有环 15.获取环链表的长度 16.获取环链表的入口节点值 17.方法测试（过程包括创建链表、构造相交链表、环链表等） public
java链表（含案例代码展示）
qq_56127002的博客
08-12 564
链表增删改查原理以及案例代码
链表知识详解及java代码示例
m0_68871967的博客
05-23 1197
这篇教学文章主要介绍了链表的基本原理和定义，以及如何使用 Java 实现链表。链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。相比于数组，链表具有动态扩展和删除节点的优势，但是访问节点的效率较低。在文章中，我们还介绍了链表的几种常见操作，包括插入节点、删除节点、查找节点等。并且均给出java示例代码。
利用java与链表的实现与应用
u012552475的博客
05-18 588
分为三步： 1、构建每个节点NodeOne，java里面没有指针，所以节点里面一般都会再包含一个节点NodeOne，其值会等于下一个节点，所以代码如下： package com.heshufan.list_mul_acount; public class Nodeone{ private int a; private int i; public Nodeone next; pub
Java 与数据结构（2）：链表
暗星涌动
05-15 980
链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。链表中的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向 NULL。相比于数组，链表的优点是可以动态地分配内存，不需要预先知道存储元素的个数，而且插入和删除操作的时间复杂度为 O(1)。链表常见的类型有单向链表、双向链表和循环链表。单向链表每个节点只包含一个指向下一个节点的指针，而双向链表每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。循环链表的尾节点的指针指向头节点，形成一个环。
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3685
数据结构之单链表的实现
java-- 链表的创建和应用
weixin_45350120的博客
09-14 570
链表的创方法 class ListNode{ int val; //数值 data ListNode next; // 结点 node ListNode(int x){ //可以定义一个有参构造方法，也可以定义一个无参构造方法 val = x; } // 添加新的结点 public void add(int newval) { ListNode newNode = new ListNode(newval); i
java 链表长度_java 中链表的定义与使用方法
weixin_26833503的博客
02-12 2283
java 中链表的定义与使用方法Java实现链表主要依靠引用传递，引用可以理解为地址，链表的遍历多使用递归，这里我存在一个疑问同一个类的不同对象的的相同方法的方法内调用算不算递归.这里我写的是单向链表;实例代码：package com.example.java;public class MyLink {public static void main(String [] args){Link l=n...
Java链表的实现
fengfeng的博客
08-24 4928
传统的对象数据一旦声明则长度不可改变，因此，操作起来较为繁杂。 链表从本质上讲可以理解为“动态的对象数组”。链表可以实现对象的增加、删除、查询等等一系列的操作，可以实现动态扩充。如下为链表的实现： 1、定义要保存对象的类： class Phone { //此类提供要保存的数据 private String brand ; private double price ; public P
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
HashSet的注意点
qq_41815040的博客
11-03 244
class A{     public boolean equals(Object o) {         return true;     } } class B{     public int hashCode() {         return 1;     } } class C{     public int hashCode() {         return 2;     } ...
java 链表的例子
yuanyuan214365的博客
12-03 583
package 链表; class Node { public Node next; public int data; public Node(int data){ this.data=data; this.next=null; } } public class LinkList { public N
java单链表初始化_java 实现 单链表
weixin_29281915的博客
02-25 961
classNode{public intval;publicNode next;public Node(intval){this.val=val;}}classLinkList{privateNode head;privateNode tail;//链表对象增加节点public voidaddNode(Node node){if (this.head==null){ //链表初始化，第一个节点th...
java实现链表简单示例
小9的专栏
06-27 1627
Java实现双向链表
数据结构 顺序表(1)
2401_88465894的博客
07-10 754
动态顺序表: 在空间足够的情况下，插入和删除操作与静态顺序表类似，平均时间复杂度为 O(n)而当空间不足需要扩容时，除了移动元素的开销，还需要进行动态内存分配（如用 realloc ），- 静态顺序表：如果预先分配的空间过大，会造成内存浪费；- 静态顺序表：插入和删除操作时，如果不涉及数组越界，时间复杂度主要是移动元素的开销，平。综上所述，通过静态表和动态表的对比区别，我们可以得出动态表更加全面，在写代码的过程中也。
数据结构*Set和Map类
最新发布
2401_87791120的博客
07-14 593
1、哈希表依赖hashCode()快速定位，依赖equals()确认相等。对于一个自定义类在使用hash的时候需要重写hashCode()方法和equals()方法！2、通常认为哈希表的插入/删除/查找的时间复杂度为O(1)。
Java链表详解及源码注释实例
本篇将详细讲解Java中链表的创建和使用，并通过带有大量注释的Java源代码实例，帮助初学者更好地理解链表的工作原理。 链表是由一系列节点（Node）组成的集合，每个节点包含数据域和指向下一个节点的指针域。链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值