LinkedList与链表

原创 已于 2025-07-23 13:46:23 修改 · 363 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

于 2024-10-27 14:25:31 首次发布

一、链表

链表是一种物理结构上非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的。逻辑上是连续的

2)链表结构(8种)

单向/双向+带头/不带头+循环/非循环(组合)

在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

二、链表的实现

1.有头单向非循环链表实现

代码如下（示例）：

package demo2;

public class MySingleList {
    static class ListNode{
        public int val;//结点的值
        public ListNode next;//下一个节点的地址 (引用类型)

        public ListNode(int val) {
            this.val = val;
        }
    }
        public  ListNode head;//表示当前链表的头节点
    //创建一个链表
      public void createList() {
          //构造方法

          ListNode node1=new ListNode(12);
          ListNode node2=new ListNode(23);
          ListNode node3=new ListNode(34);
          ListNode node4=new ListNode(45);
          ListNode node5=new ListNode(56);
          //以链表的方式连接起来
          node1.next=node2;
          node2.next=node3;
          node3.next=node4;
          node4.next=node5;
          this.head=node1;


      }
    public void display() {
//          while (head!=null){
//              System.out.print(head.val+" ");
//              head=head.next;
//          }
//          //换行
//        System.out.println();
//    }
         ListNode cur=head;
        while (cur!=null){
            System.out.print(cur.val+" ");
            //cur=null证明链表遍历完成了
            cur=cur.next;
        }
        //换行
        System.out.println();
    }




    //头插法
    public void addFirst(int data){
          //在插入的时候先绑定后面节点的信息
        ListNode node=new ListNode(data);
        node.next=head;
        head=node;
    }
    //尾插法
    public void addLast(int data){
        ListNode node=new ListNode(data);
        ListNode cur=head;
        //cur/head==null cur.next空指针异常
        if (cur==null){
            head=node;
            return;
        }
        //cur.next==null说明cur所指向的节点是尾巴节点
        //cur==null代表把链表的每个节点都遍历完了
        while (cur.next!=null){
            cur=cur.next;
            }
        cur.next=node;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
          if(index<0||index>size()){
              System.out.println("index 不合法");
              return;
          }
          if(index==0){
              //头插法
              addFirst(data);
              return;
          }
          if (index==size()){
              //尾插法
              addLast(data);
              return;
          }
          //定义cur走index-1步,找到插入位置的前一个插入
        ListNode cur=findIndexSubOne(index);
          ListNode node=new ListNode(data);
          node.next=cur.next;
          cur.next=node;

    }
    //要找节点的前一个节点
    private ListNode findIndexSubOne(int index){
          ListNode cur=head;
          int count=index-1;
          while (count!=0){
              cur=cur.next;
              count--;
          }
          return cur;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur=head;
        while (cur!=null){
           if(cur.val==key){
               return true;
           }
           cur=cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
          if(head==null){
              return;
          }
          if(head.val==key){
              head=head.next;
              return;
          }
         ListNode cur=searchPrev(key);
         if (cur==null){
             System.out.println("没有你要删除的数字");
             return;
         }
         ListNode del=cur.next;
         cur.next=del.next;
    }
    //要删除值的节点的前一个节点
    private ListNode searchPrev(int key){
        ListNode cur=head;
        while (cur!=null){
            if(cur.next.val==key){
                return cur;
            }
            cur=cur.next;
        }
        return null;
    }

    //删除所有值为key的节点
    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;
          }
    }
    //得到单链表的长度
    public int size(){
          int count=0;
        ListNode cur=head;
        while (cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }
    public void clear() {
          this.head=null;
    }

}
class Test{
    public static void main(String[] args) {
        MySingleList mySingleList=new MySingleList();
        mySingleList.createList();
        mySingleList.display();
        System.out.println("2.===========");
        //链表长度
        System.out.println(mySingleList.size());
        //判断123是否在单链表中
        System.out.println(mySingleList.contains(123));
        System.out.println("头插999");
        mySingleList.addFirst(999);
        mySingleList.display();
        System.out.println("尾插888");
        mySingleList.addLast(888);
        mySingleList.display();
        System.out.println("1位置插入7");
        mySingleList.addIndex(1,7);
        mySingleList.display();
        System.out.println("删除999");
        mySingleList.remove(999);
        mySingleList.display();
        System.out.println("删除所有的12");
        mySingleList.addFirst(12);
        mySingleList.display();
        mySingleList.removeAllKey(12);
        mySingleList.display();
        System.out.println("删除所有节点");
        mySingleList.clear();
        System.out.println(mySingleList.size());


    }
}

 

2.代码解析

1)打印 :这种方法打印最后头节点为空(打印后找不到头节点)  //创建临时节点cur

2)任意位置插入元素

被插入位置的前一个节点cur

node.next=cur.next;

cur.next=node;

3)删除节点

找到要删除节点的前一个节点

删除 cur.next=del.next

4)常用方法

boolean add(E e) 尾插 e

void add(int index, E element) 将 e 插入到 index 位置

boolean addAll(Collection 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

三、ArrayList和LinkedList的区别 

不同点    ArrayList                                       LinkedList

存储空间上    物理上一定连续                     逻辑上连续，但物理上不一定连续

随机访问    支持O(1)                                   不支持：O(N)

头插    需要搬移元素，效率低O(N)             只需修改引用的指向，时间复杂度为O(1)

插入     空间不够时需要扩容                        没有容量的概念

应用场景    元素高效存储+频繁访问            任意位置插入和删除频繁

LinkedList vs ArrayList

内部实现
  • LinkedList：基于双向链表实现。每个元素（节点）包含对前一个和后一个节点的引用。这使得LinkedList在插入和删除操作时不需要移动其他元素，因此在列表中间执行这些操作效率更高。
  • ArrayList：基于动态数组实现。它提供了对元素的随机访问能力，因为可以通过索引直接访问元素。然而，在进行插入或删除操作（特别是列表中部的操作）时，可能需要移动元素以保持连续性，这会带来额外的时间开销。
性能特点
  • LinkedList：
    • 插入和删除操作（尤其是两端）效率高，时间复杂度为O(1)。
    • 随机访问元素效率低，时间复杂度为O(n)，因为需要从头或尾遍历到指定位置。
  • ArrayList：
    • 支持快速随机访问，时间复杂度为O(1)。
    • 插入和删除操作（尤其是在列表中部）效率较低，时间复杂度为O(n)，因为需要移动元素。
适用场景
  • LinkedList：适用于频繁进行插入和删除操作的场景，如实现栈和队列等数据结构。
  • ArrayList：适用于需要频繁访问元素，而插入和删除操作相对较少的场景。
奈葵
关注
一：单链表——③查询倒数第k个节点（O(1)）
genzld的博客
07-22 869
制作人  ：TheShyclear 制作时间：2018-7-21 制作内容：查找单链表中的倒数第k个数据 版本号 ：8.0   缺陷：头节点只能插入一次，不能在1号节点出插入，详细看Insert函数 注意：头指针的不可改变性 思路：单链表中的许多问题需要用到两个指针的配合，因为单链表只有后继节点，无法找到后继节点。     当我们拿到这个问题时，第一反应肯定是：用一个指针指向头...
链表的插入、删除、查找
weixin_47779418的博客
07-17 162
//创建链表 class DoubleList{ public int val; public DoubleList(int val) { this.val = val; } public DoubleList() { } public DoubleList pre; public DoubleList next; } //对进行操作链表的方法具体实现 public class DoubleLinkedList { pub
【单链表】初始化、插入、删除、查找
qq_52639249的博客
06-01 2091
单链表基本操作
链表定义、链表的插入、链表的删除、链表的查找
weixin_41679960的博客
04-28 325
链表的定义 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。 结构体形式 struct test
LinkedList双向链表的详细介绍
最新发布
qq_68754937的博客
07-11 1698
在Java源代码中，可以看出其常用的父接口有List接口，而List接口又继承于Collection接口，由此可以推断出：LinkedList类父接口为List，祖宗接口为Collection。5.根据指定索引删除元素public E remove(int index)，首先对index索引进行校验，校验通过后调用unlink(Node x)方法，判断要删除的元素所处的位置，进行不同的操作，最后把要删除的元素清空，减小集合大小，增加修改计数器。
LinkedList和链表
2301_78804510的博客
04-21 1445
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 2119
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
一看就会-链表的插入删除查找
qq_44805265的博客
07-24 595
插入操作：插入节点的操作是将值为X的结点插入到单链表的第i个位置上。先检查插入位置的合法性，然后找到待插入位置的前驱结点，即第i-1个结点，再起后插入新的结点。 //此方法为常用的前插操作 void insert(LinkList head,int pos,int x){ //pos为插入的位置，x为插入的值 LinkList p=head; for(int i=0;i<pos-1;i++){ p=p->next; } Lnode *q=new Lnode; q->
数据结构 链表插入删除查找
qq_48403611的博客
09-17 400
#include <stdio.h> #include <stdlib.h> //定义一个结构体 typedef struct Node{ int data; struct Node *next; }Node,* LinkList; //链表的初始化操作 void InitList(LinkList * L) { (*L)=(LinkList)malloc(sizeof(Node)); (* L)->next=NULL; } //采用
数据结构---链表
每天都要努力学习哦~~
04-18 775
目录 链表的概念 封装单项链表 封装链表结构 append方法（追加元素） toString方法（转字符串） insert方法（插入元素） get方法（获取元素） indexof（获取索引） update修改某个位置的元素 removeAt方法（删除元素，根据索引） remove(删除数据，根据元素) isEmpty&&size方法 单想链表vs双向链表 封装双向链表 双向链表的特点 封装链表结构 append方法（追加元素） toString方法..
链表的查找、删除、插入
qq_72873217的博客
12-07 4680
链表的查找、删除、插入
链表的初始化、取值、查找、插入、删除
m0_68002095的博客
03-13 4750
以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。在`getVal`函数中，使用循环遍历链表中的节点，如果找到了第`i`个节点，则返回其值。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。缺点是访问节点的时间复杂度为 O(n)，其中 n 表示链表的长度。
C语言数据结构 单链表的建立、遍历、查找、插入和删除操作
热门推荐
追求。
04-26 1万+
链表（Linked List）是一种物理存储单元上非连续、非顺序的数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（node，链表中每一个元素称为结点）组成，每一次为一个结构体 动态分配的内存空间，可称之为一个结点，每个结点之间可以是不连续的，但结点内是连续的。结点个数是不受限定的，可以随时删改，这是与数组相比的优点。.........
链表学习(链表的创建，插入，删除，查找，遍历)
hello
03-24 2735
链表学习(链表的创建，插入，删除，查找，遍历)
7-6 链表操作-插入、查找和删除 (100 分)
qq_56165953的博客
06-16 2063
请编写创建链表和输出链表的函数。对于以下数据结点的结构定义， 针对带头结点的链表，请编程完成以下功能。 struct LNode{ int data; //数据域 struct LNode *next; //指针域 }; struct LNode *head; //头指针 输入数据包含若干组命令和数据，一组数据中的第1个字符代表命令， 接下来的是该命令需要的数据。 (1)如果命令是I，功能为创建空链表，对应函数：void List_In.
数据结构C语言 单链表（插入、删除、查找）
更多资料私我
09-08 7446
数据结构C语言 单链表（插入、删除、查找） 1、插入 假设_A_的临时指针为 “p” ，C_的临时指针为 “q“。 步骤1： _ 删除这条连接线； 步骤2： 将p->next给q->next； 步骤3： 将q给p->next； 插入代码 q->next = p->next; p->next = q; 2、删除 假设_A_的临时指针为 “p” ，_B_的临时指针为 “q“。 步骤1： 删除这条连接线； 步骤2： 删除这条连接线； 步骤3： 将p->next给q，接着
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值