单链表LinkedList的增删改查

最新推荐文章于 2024-04-18 00:08:02 发布
最新推荐文章于 2024-04-18 00:08:02 发布
阅读量549 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wardo_l/article/details/114370306
版权

数组作为数据存储结构有一定的缺陷。在无序数组中，搜索性能差，在有序数组中，插入效率又很低（插入位置后面的元素需要集体后移），而且这两种数组的删除效率（集体前移）都很低，并且数组在创建后，其大小是固定了，设置的过大会造成内存的浪费，过小又不能满足数据量的存储。

数组是一种通用的数据结构，能用来实现栈、队列等很多数据结构。而链表也是一种使用广泛的通用数据结构，它也可以用来作为实现栈、队列等数据结构的基础，基本上除非需要频繁的通过下标来随机访问各个数据，否则很多使用数组的地方都可以用链表来代替。

注意：链表是不能解决数据存储的所有问题的，它也有它的优点和缺点。本篇博客我们介绍几种常见的链表，分别是单向链表、双端链表、有序链表、双向链表以及有迭代器的链表。并且会讲解一下抽象数据类型（ADT）的思想，如何用 ADT 描述栈和队列，如何用链表代替数组来实现栈和队列。

头指针一定指向链表的第一个结点，有头结点就指向头结点，没有则指向第一个元素结点。

头结点，指向第一个元素结点，data域可为空，也可存放一些链表的信息，作用就是表示单链表的头。

链表通常由一串节点组成，每个节点包含任意的实例数据域(data fields)和一个或两个来指向上一个或下一个节点的位置的指针域(next/prev fields)。链表节点的存储位置可能不连续。

链表分带头结点的链表和不带头结点的链表，根据实际需求来确定。

 

1.单向链表

单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们提供在链表头插入或链表尾插入，只需要将当前插入的节点设置为头节点指向的节点，next指向原头节点指向的节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

尾结点的指针域指向null。

举例：

使用带头结点head的单向链表实现--水浒英雄排行榜管理

1）完成对英雄人物的增删改查操作；

2）第一种方式，直接添加到链表的尾部；

3）第二种方式，根据排名将英雄插入到指定位置（如果该排名已有人，则添加失败，并给出提示）

思路：

添加（创建）

1.先创建一个head头结点，作用就是表示单链表的头

2.后面我们每添加一个节点，就直接加入到链表的最后（尾插法）

遍历：

通过一个辅助遍历：帮助遍历整个链表

public class DemoSingleLinkedList {
    public static void main(String[] args) {
        // 测试
        // 先创建节点
        Node hero1 = new Node(1,"宋江","及时雨");
        Node hero2 = new Node(2,"卢俊义","玉麒麟");
        Node hero3 = new Node(3,"吴用","智多星");
        Node hero4 = new Node(4,"公孙胜","入云龙");

        // 创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addRear(hero1);
        singleLinkedList.addRear(hero4); // 尾插法打乱顺序后，影响排列。不符合题目要求
        singleLinkedList.addRear(hero2);
        singleLinkedList.addRear(hero3);

        // 显示
        singleLinkedList.show();
    }
}

// 定义SingleLinkedList 单链表 管理英雄
class SingleLinkedList{
    // 先初始化一个头结点，头结点不要动
    private Node head = new Node(0,"","");
    private Node rear; // 本质是赋值地址

    // 构造器
    public SingleLinkedList() {
        // 初始化
        head.next = null; //指针域问题
        rear = head;
    }

    // 尾插法添加节点到单向链表
    public void addRear(Node node){
        // 尾插法
        node.next = null;
        rear.next = node; // 插入尾结点
        rear = node; // 尾指针后移
    }

    // 头插法添加节点到单向链表
    public void addHead(Node node){
        // 头插法，
        Node temp = head.next; // 暂存地址
        head.next = node;
        node.next = temp;
    }

    // 显示链表（遍历）
    public void show(){
        // 先判断链表是否为空
        if(head.next == null) System.out.println("链表为空");
        // 因为头结点不能动，需要一个辅助变量来遍历
        Node temp = head.next;
        while(temp != null){ // 链表不为空
            System.out.println(temp.toString()); // 输出节点信息
            temp = temp.next; // 指针后移
        }
    }
}
// 定义node节点，每个node对象就是一个节点
class Node{
    public int id; // 编号
    public String name; // 姓名
    public String nickName; // 英雄名
    // 因为一个节点就是这个Node类的实例对象，那么它存储的就是该对象的地址值。
    // 而指针域的作用就是指向下一个节点的地址，所以类型就是Node
    public Node next; // 指向下一个节点

    // 构造器
    public Node(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    // 显示方便，重写toString方法
    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                // ", next=" + next +
                '}';
    }
}

可以注意到，尾插法需要输入节点有序，如果输入节点无序，那么链表就也不会按排位来，接下来介绍一种中插法：按排名来添加，（如果该排名节点已存在，则添加失败，给出提示）

思路：

1.首先找到新添加节点的位置；

2.新的节点的next域指向下一个，上一个节点的next域指向新节点。

public class DemoSingleLinkedList {
    public static void main(String[] args) {
        // 测试
        // 先创建节点
        Node hero1 = new Node(1,"宋江","及时雨");
        Node hero2 = new Node(2,"卢俊义","玉麒麟");
        Node hero3 = new Node(3,"吴用","智多星");
        Node hero4 = new Node(4,"公孙胜","入云龙");

        // 创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4); // 尾插法打乱顺序后，影响排列。不符合题目要求
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero4);


        // 显示
        singleLinkedList.show();
    }
}

// 定义SingleLinkedList 单链表 管理英雄
class SingleLinkedList{
    // 先初始化一个头结点，头结点不要动
    private Node head = new Node(0,"","");
    private Node rear; // 本质是赋值地址

    // 构造器
    public SingleLinkedList() {
        // 初始化
        head.next = null;
        rear = head;
    }

    // 尾插法添加节点到单向链表
    public void addRear(Node node){
        // 尾插法
        node.next = null;
        rear.next = node; // 插入尾结点
        rear = node; // 尾指针后移
    }

    // 头插法添加节点到单向链表
    public void addHead(Node node){
        // 头插法，
        Node temp = head.next; // 暂存地址
        head.next = node;
        node.next = temp;
    }

    // 有序中插法
    public void addByOrder(Node node){
        // 遍历找到该位置，所以需要辅助指针
        Node temp = head;
        while(true){
            if(temp.id == node.id) { // 已存在排名 // 注意这个if要写在三个if的最前面，否则陷入死循环
                System.out.println("该排名英雄已存在！");
                break;
            }
            if(temp.next == null){
                // 链表为空或遍历到最后了，插在尾部
                addRear(node);
                break;
            }
            if(temp.id < node.id && temp.next.id > node.id){
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }

    // 显示链表（遍历）
    public void show(){
        // 先判断链表是否为空
        if(head.next == null) System.out.println("链表为空");
        // 因为头结点不能动，需要一个辅助变量来遍历
        Node temp = head.next;
        while(temp != null){ // 链表不为空
            System.out.println(temp.toString()); // 输出节点信息
            temp = temp.next; // 指针后移
        }
    }
}
// 定义node节点，每个node对象就是一个节点
class Node{
    public int id; // 编号
    public String name; // 姓名
    public String nickName; // 英雄名
    // 因为一个节点就是这个Node类的实例对象，那么它存储的就是该对象的地址值。
    // 而指针域的作用就是指向下一个节点的地址，所以类型就是Node
    public Node next; // 指向下一个节点

    // 构造器
    public Node(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    // 显示方便，重写toString方法
    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                // ", next=" + next +
                '}';
    }
}

运行截图：

可以看到，虽然重复插入的节点是最后插入的，但提示该英雄存在的信息是最先打印的，是因为，节点类本身就是递归嵌套定义的的，所以打印第一个是需要先找到最后一个的，而找到最后一个就会打印这句话。

单线链表的修改：

仍旧以这个例子，修改是指修改名字和昵称，编号不可修改（会打乱顺序)

    public static void main(String[] args) {
        // 测试
        // 先创建节点
        Node hero1 = new Node(1,"宋江","及时雨");
        Node hero2 = new Node(2,"卢俊义","玉麒麟");
        Node hero3 = new Node(3,"吴用","智多星");
        Node hero4 = new Node(4,"公孙胜","入云龙");

        // 创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4); // 尾插法打乱顺序后，影响排列。不符合题目要求
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero4);

        // 显示
        System.out.println("原链表：");
        singleLinkedList.show();
        System.out.println("---------------");

        System.out.println("修改后的链表：");
        singleLinkedList.update(new Node(3,"小鹿","牛年大吉"));
        singleLinkedList.show();
    }
}

// 定义SingleLinkedList 单链表 管理英雄
class SingleLinkedList{
    // 先初始化一个头结点，头结点不要动
    private Node head = new Node(0,"","");
    private Node rear; // 本质是赋值地址

    // 构造器
    public SingleLinkedList() {
        // 初始化
        head.next = null;
        rear = head;
    }

    // 尾插法添加节点到单向链表
    public void addRear(Node node){
        // 尾插法
        node.next = null;
        rear.next = node; // 插入尾结点
        rear = node; // 尾指针后移
    }

    // 头插法添加节点到单向链表
    public void addHead(Node node){
        // 头插法，
        Node temp = head.next; // 暂存地址
        head.next = node;
        node.next = temp;
    }

    // 有序中插法
    public void addByOrder(Node node){
        // 遍历找到该位置，所以需要辅助指针
        Node temp = head;
        while(true){
            if(temp.id == node.id) { // 已存在排名
                System.out.println("该排名英雄已存在！");
                break;
            }
            if(temp.next == null){
                // 链表为空或遍历到最后了，插在尾部
                addRear(node);
                break;
            }
            if(temp.id < node.id && temp.next.id > node.id){
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }


    // 修改节点信息，根据编号修改。
    /*
    说明根据node的id来修改
     */
    public void update(Node node){
        // 判断链表是否为空
        if(head.next == null) System.out.println("链表为空");
        // 找到需要修改的节点
        // 定义一个辅助变量
        Node temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null) {// 链表为空，或遍历到最后一个节点了
                break;
            }
            if(temp.id == node.id){ // 找到节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = node.name;
            temp.nickName = node.nickName;
        }else System.out.println("没有找到该编号英雄！");
    }
    // 显示链表（遍历）
    public void show(){
        // 先判断链表是否为空
        if(head.next == null) System.out.println("链表为空");
        // 因为头结点不能动，需要一个辅助变量来遍历
        Node temp = head.next;
        while(temp != null){ // 链表不为空
            System.out.println(temp.toString()); // 输出节点信息
            temp = temp.next; // 指针后移
        }
    }
}
// 定义node节点，每个node对象就是一个节点
class Node{
    public int id; // 编号
    public String name; // 姓名
    public String nickName; // 英雄名
    // 因为一个节点就是这个Node类的实例对象，那么它存储的就是该对象的地址值。
    // 而指针域的作用就是指向下一个节点的地址，所以类型就是Node
    public Node next; // 指向下一个节点

    // 构造器
    public Node(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    // 显示方便，重写toString方法
    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                // ", next=" + next +
                '}';
    }

运行截图：

删除节点：

// 删除节点
public void deleteNode(Node node){
    Node temp = head; // 遍历指针
    boolean flag = false;
    while(true) {
        if (temp.next == null) { // 链表为空或遍历到最后了
            break;
        }
        if (temp.next.id == node.id) { // 找到该节点的前驱节点
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if(flag){
        temp.next = temp.next.next;
    }else{ // 遍历到最后也没找到
        System.out.println("链表中不存在该节点");
    }
}
System.out.println("删除节点后的链表：");
singleLinkedList.deleteNode(hero4);
singleLinkedList.show();

运行截图：

根据id查找结点：

// 根据id查找结点
public Node get(int id){
    Node temp = head; // 遍历指针
    Node result = null;
    boolean flag = false;
    while(true){
        if(temp.id == id){ // 这个if要放在判空if前面，避免是最后一个节点
            result = temp;
            flag = true;
            break;
        }
        else if(temp.next == null){ // 链表为空，或找到最后一个节点了  
            break;
        }
        temp = temp.next;
    }
    if(flag) return result;
    else throw new NullPointerException("该节点不存在！");
}
System.out.println("根据id查找的链表：");
System.out.println(singleLinkedList.get(1).toString());
System.out.println("---------------");

运行截图：

 

参考博客：

https://www.cnblogs.com/ysocean/p/7928988.html#_label3

wardoluo
关注
专栏目录
LinkedList的增删改查，以及源码分析
m0_63816662的博客
12-29 748
package one.Two.List; import java.util.Iterator; import java.util.LinkedList; @SuppressWarnings({"all"}) public class LinkedListCRUD { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); linkedList.add(1.
golang单链表（增删改查）
疯狂的鸭血
10-09 1223
单链表－LinkedList 链表（Linked list）是一种常见的基础数据结构，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。由于不是必须按顺序存储，链表在插入的时候可以达到O(1)，比顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间。 单链表的示意图： 说明：一般来说，为了比较好的对单链表进行增删改查，我们都会给它设置一个头结点，头结点的...
手写LinkedList代码(增删改查)笔记
吐蕃圣僧
06-25 308
开始的时候作者觉得这还不简单, 开始写的时候才发现键盘按不下去, 通过反复的阅读jdk的源码和反复的编写, 作者终于可以无压力的写出增删改查 给初学源码的同学们建议, 最好还是自己去实现一遍 下面是代码, 经过反复的阅读, 作者的代码已经和jdk的代码有高度的相似, 也有很多不足的地方 /** * 自己实现一个双向链表 */ public class MyLinkedList<E> { /** * 当前链表长度 */ private int size; /** *.
LinkedList源码（基础代码）
weixin_33919941的博客
12-23 116
LinkedList是由一个一个节点连接起来的链表 private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E...
写一个简单的Linkedlist，实现增删改查
go_____________ahead的博客
11-22 1189
linkedlist和arraylist一样都是实现了list，只是它们底层不同，一个是数组一个是链表，就造就了它们的一些特性不同 linkedlist增删快，查找慢。主要是因为链表查找要将链表遍历一边找到该数据输入。当要删除时，只需要将其结点的前后两个结点连接起来即可 package Array; import java.util.NoSuchElementException; pub...
Java集合详解——LinkedList类（包括：增删改查 源代码逐步分析）
m0_75013084的博客
04-18 1045
（1）LinkedList类是List接口的实现子类。（2）LinkedList底层实现了 双向链表和双端队列 特点。（3）可以添加任意元素（元素可以重复)，包括null。（4）线程不安全，没有实现同步。
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
用Python体现单链表的增删改查
10-15
这里是一个简单的单链表类的实现，包括增删改查操作： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None...
尾插法建立单链表极其增删改查源代码
最新发布
10-27
以下是使用Python实现的简单单链表增删改查操作的示例： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __init__(self): self.head = ...
C#实现单链表的增删改查
08-08
在本文中，我们将深入探讨如何使用C#编程语言实现单链表，并结合图形用户界面（GUI）来实现增、删、改、查等基本操作。单链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据以及指向下一个节点的引用...
java LinkedList的添加删除操作
06-21
java LinkedList的添加删除操作 java LinkedList的添加删除操作
LinkedList 特点及增删改查源码解析
CoderThc
09-10 338
特点 双向链表存储数据 查询慢、增删除快 1.构造方法 public LinkedList() { } public LinkedList(Collection<? extends E> c) { this(); // 调用addAll 详见2.4 addAll(c); } 1.1 双向链表Node private static class Node<E...
Jakarta EE（原J2 EE）菜鸟之LinkedList的增删改查
z2014ypd的博客
12-22 265
对LinkedList进行增删改查 LinkedList是双向链表，实现了List的接口的容器类，存储数据使用的是地址，始终铭记一点，对链表的操作就是对地址的操作，虽然有索引，但是一切都是以地址为准，对数据进行添加和删除插入的操作就十分迅速。接下来我们实现以下小功能： 添加元素功能 /**首先，我们要创建一个临时指针，用于地址的指向*/ /**内部类，存值的类型*/ class Node{ ...
list集合的增删改查&循环方式&去重&集合优化&linkedlist
qq_66924116的博客
06-07 562
list集合的增删改查&循环方式&去重&集合优化&linkedlist
关于ArrayList与LinkedList的增删改查
phn555的博客
03-25 590
都说链表增删快，查询慢，数组查询快，增删慢，但是关于ArrayList和LinkedList，你真的用对了吗？有对比过各个方面之间的性能吗？ 下面的测试以500000条为例： 插入： public static void main(String[] args) { int num = 500000; test1(num); } private...
LinkedList的增删改查源码分析
10-30 1082
LinkedList是一个双向链表，也可以当做堆栈、队列、双向队列进行操作。 1. LinkedList增加元素的方法 public boolean add(E e)，将指定元素添加到此列表的结尾。此方法等效于public void addLast(E e)。 public boolean add(E e) { linkLast(e); r
LinkedList源码笔记 --- 普通增删查改
安歌
07-16 312
LinkedList源码笔记 — 普通增删查改 这次先看一下类关系图: 嗯就是这样,这货不止是List的实现类,而且也是Queue的实现类。 特此说明下：Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 再看看类介绍(这里偷懒了一下看看JDK1.8帮助文档): public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,
LinkList的增删查改
weixin_30559481的博客
12-22 88
package com.lanyuan.log; public class Test1 { private TNode head; private int size; private TNode last; public int size() { return this.size + 1; } ...
LinkedList数组列表内部增删改查源码分析
m0_51660523的博客
03-01 220
本文对源码中的注释进行了翻译解读，源码注释需查阅源码 一、增 将指定的元素追加到此列表的末尾，这个方法相当于addLast。 参数 e 要追加到此列表的E类元素 返回 boolean (由Collection.add指定) public boolean add(E e) { linkLast(e); return true; } 将指定的元素插入到此列表中的指定位置。将当前位置的元素(如果有的话)和随后的元素向右移动(给它们的
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值