链表-java语言描述

最新推荐文章于 2022-12-28 22:37:26 发布
最新推荐文章于 2022-12-28 22:37:26 发布
阅读量289 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44561426/article/details/122199708
版权
这篇博客详细介绍了链表的概念，包括单向链表、单向循环链表、双向链表和双向循环链表。讨论了链表的基本操作，如添加、删除、更新、查找和遍历，并提供了完整的Java源码实现。

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

链表

1、单向链表

1.1、概念
  • 链表是一个有序的列表
  • 链表不同于数组，链表是以节点的形式存储，在物理空间上不一定连续
  • 链表的每个节点的内部包含data（数据）域，指向后一个节点next（指针）域，如果是双向链表，还有一个指向前一个节点的previous （指针）域
  • 链表的头结点不存储数据，只是为了指向链表的开头
1.2、对链表的操作
1.2.1、添加
//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }

    /**
     * 添加一个节点到链表之中（优化后的版本）
     * 要根据人物的编号来插入到指定的位置（如果已经有了这个编号的人物，则添加失败，并给出提示）
     *
     * @param node 你要添加的节点
     */
    public void adds(Node node) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了该节点应该插入的位置
            if (temp.getNext().getId() > node.getId()) {
                break;
            }
            //新节点的编号已经存在，给出提示信息
            if (temp.getNext().getId() == node.getId()) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是添加还是给出提示信息
        if (flag) {
            System.out.println(node.getId() + " 该节点已经存在，不能加入！");
        } else {
            node.setNext(temp.getNext());
            temp.setNext(node);
        }
    }
}
1.2.2、删除
//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }
    
    /**
     * 根据传入的 id删除该节点
     *
     * @param id 要删除节点的 id
     */
    public void delete(int id) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要删除的节点
            if (temp.getNext().getId() == id) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            temp.setNext(temp.getNext().getNext());
        } else {
            System.out.println(id + " 该节点不存在，不能删除");
        }
    }
}
1.2.3、更新
//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }
    /**
     * 更新数据
     *
     * @param oldId 要改变的节点的 id
     * @param newId 更新之后的节点的 id
     */
    public void update(int oldId, int newId,String newAddress) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要更新的节点
            if (temp.getId() == oldId) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            temp.setId(newId);
            temp.setAddress(newAddress);
        } else {
            System.out.println(oldId + " 该节点不存在，不能更新");
        }
    }
}
1.2.4、查找
//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }
    /**
     * 查找节点
     *
     * @param id        要查找节点的 id
     * @return          返回该节点
     */
    public Node find(int id){
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要更新的节点
            if (temp.getId() == id) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            return temp;
        } else {
            return null;
        }
    }
}
1.2.5、遍历
//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }
    //遍历当前环形链表
    public void showNode() {
        //判断链表是否为空
        if (head == null) {
            System.out.println("该链表为空");
            return;
        }
        //因为head不能动，所以使用一个辅助指来完成遍历
        Node temp = head.getNext();

        while (true) {
            System.out.println("id为：" + temp.getId() + "   地点为："+temp.getAddress());
            //说明已经遍历完毕
            if (temp.getNext() == null) {
                break;
            }
            //temp后移
            temp = temp.getNext();
        }
        System.out.println();
        System.out.println("---------------------");
    }
}
1.3、完整的源码
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.adds(new Node(3,"北京"));
        singleLinkedList.adds(new Node(1,"天津"));
        singleLinkedList.adds(new Node(2,"上海"));
        singleLinkedList.adds(new Node(4,"深圳"));
        singleLinkedList.adds(new Node(0,"广东"));
        singleLinkedList.showNode();

        singleLinkedList.delete(1);
        singleLinkedList.showNode();

        singleLinkedList.update(3, 7,"南昌");
        singleLinkedList.showNode();

        Node node = singleLinkedList.find(3);
        if (node != null){
            System.out.println("查找到了id为："+node.getId()+"  地址为："+node.getAddress());
        }else {
            System.out.println("该节点不存在");
        }

    }
}

//创建一个单向循环链表
class SingleLinkedList {
    //设置一个头节点，头节点是固定的，无任何数据
    private Node head = new Node(-1,"");

    public Node getHead() {
        return head;
    }

    /**
     * 添加一个节点到链表之中（优化后的版本）
     * 要根据人物的编号来插入到指定的位置（如果已经有了这个编号的人物，则添加失败，并给出提示）
     *
     * @param node 你要添加的节点
     */
    public void adds(Node node) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了该节点应该插入的位置
            if (temp.getNext().getId() > node.getId()) {
                break;
            }
            //新节点的编号已经存在，给出提示信息
            if (temp.getNext().getId() == node.getId()) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是添加还是给出提示信息
        if (flag) {
            System.out.println(node.getId() + " 该节点已经存在，不能加入！");
        } else {
            node.setNext(temp.getNext());
            temp.setNext(node);
        }
    }

    /**
     * 根据传入的 id删除该节点
     *
     * @param id 要删除节点的 id
     */
    public void delete(int id) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要删除的节点
            if (temp.getNext().getId() == id) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            temp.setNext(temp.getNext().getNext());
        } else {
            System.out.println(id + " 该节点不存在，不能删除");
        }
    }

    /**
     * 更新数据
     *
     * @param oldId 要改变的节点的 id
     * @param newId 更新之后的节点的 id
     */
    public void update(int oldId, int newId,String newAddress) {
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要更新的节点
            if (temp.getId() == oldId) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            temp.setId(newId);
            temp.setAddress(newAddress);
        } else {
            System.out.println(oldId + " 该节点不存在，不能更新");
        }
    }

    /**
     * 查找节点
     *
     * @param id        要查找节点的 id
     * @return          返回该节点
     */
    public Node find(int id){
        //因为头节点的固定的，不能动，所以我们定义一个辅助遍历temp
        Node temp = head;
        //表明该节点是否存在
        boolean flag = false;

        while (true) {
            //当该链表到了最后一个节点
            if (temp.getNext() == null) {
                break;
            }
            //表示已经找到了要更新的节点
            if (temp.getId() == id) {
                flag = true;
                break;
            }
            //如果不是最后一个节点，则将temp后移
            temp = temp.getNext();
        }
        //根据flag的值来判断是删除还是给出提示信息
        if (flag) {
            return temp;
        } else {
            return null;
        }
    }

    //遍历当前环形链表
    public void showNode() {
        //判断链表是否为空
        if (head == null) {
            System.out.println("该链表为空");
            return;
        }
        //因为head不能动，所以使用一个辅助指来完成遍历
        Node temp = head.getNext();

        while (true) {
            System.out.println("id为：" + temp.getId() + "   地点为："+temp.getAddress());
            //说明已经遍历完毕
            if (temp.getNext() == null) {
                break;
            }
            //temp后移
            temp = temp.getNext();
        }
        System.out.println("---------------------");
    }
}

//创建一个节点类
class Node {
    private int id;
    private String address;
    private Node next;

    public Node() {
    }

    public Node(int id, String address) {
        this.id = id;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

2、单向循环链表

3、双向链表

4、双向循环链表

5、小结

​ 其实剩下的这些都是在单向链表的基础上进行进一步的优化。

如：

  1. 单向循环链表就是在单向链表的基础上，将链表的最后一个节点的 next指向了第一个节点，而单向链表的最后一个节点的 next是指向 null
  2. 双向链表就是在单向链表的基础上，在每一个节点都加上一个 previous，这个 previous指向上一个节点
  3. 双向循环链表是在双向链表的基础上，将链表的第一个节点的 previous指向了最后一个节点，将链表的最后一个节点的 next指向了第一个节点，而双向链表的第一个节点的 previous指向 null，双向链表的最后一个节点的 next是指向 null
数据结构--链表(java语言描述)
qq_36906588的博客
01-03 624
链表 链表的定义 链表的组成 对链表的操作(增删查改)
java 链表
qq_57163230的博客
06-25 707
Java实现单链表，双向链表，循环链表。
链表的实现(Java语言描述)
weixin_33835103的博客
10-14 130
代码如下： public interface ListInterface<T> { public T getElem(int i); public boolean insertElem(int i,T t); public T deleteElem(int i); }   public class Node<T> { public T da...
链表（Java描述）
龙之梦
02-16 2774
原文地址：http://www.cs.cmu.edu/~adamchik/15-121/lectures/Linked%20Lists/linked%20lists.html 引言         使用数组来存储数据的一个缺点在于，数组是静态结构，因此不能很容易地扩展或缩小以适合数据集。对数组进行插入和删除的代价也比较高。本文考虑一种名为链表的数据结构，解决了数组的一些局限性。
单链表的Java语言实现
weixin_43843795的博客
10-02 265
单链表的Java语言实现单链表Java代码实现单链表的功能 单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 Java代码实现单链表的功能 package com.oracle.node; //一个节点 public class Node { //节点内容 int data; //下一个节点 Node next; public Node...
数据结构与算法经典问题解析-Java语言描述
08-14
这本书“数据结构与算法经典问题解析-Java语言描述”旨在帮助读者深入理解这些概念，并通过具体的Java代码实现来提升解决实际问题的能力。 1. **数据结构**： - **数组**：是最基本的数据结构，它是一系列相同类型...
algorithm-java:常用算法-java语言描述
05-21
algorithm-java cn.fh.search 二分查找 多线程同时查找 cn.fh.sort 选择排序 插入排序 希尔排序 快速排序 cn.fh.datastructure 基于动态数组的栈 基于链表的栈 基于链表的队列 优先队列 二叉查找树 cn.fh.apply ...
数据结构与算法--Java语言描述
01-06
在这个“数据结构与算法--Java语言描述”的资料中，我们有望深入理解这些核心概念，并通过Java语言来实现它们，从而提升编程技能。 数据结构是组织和存储数据的方式，它决定了数据的访问效率和操作复杂性。常见的...
数据结构与算法分析-Java语言描述(第3版)源码.rar
03-18
《数据结构与算法分析-Java语言描述(第3版)源码》是计算机科学领域的一本经典教材，主要关注如何用Java语言实现各种数据结构和算法。这本书的第三版不仅涵盖了基本的数据结构如数组、链表、栈、队列、树、图，还深入...
链表描述
char_c的博客
07-04 623
线性表的链表描述
单链表-JAVA语言实现
Lau's Blog
06-16 389
定义一个类，用来实现单链表的基本操作。 public class Node { //节点内容 int data; //下一个节点 Node next; //构造函数 public Node(int data) { this.data = data; } //为节点追加节点 public Node append(Node node) { //方法1 // t...
链表简单描述
qq_63250428的博客
07-23 664
链表
单链表的简单实现(java语言)
weixin_38370028的博客
11-30 230
public class HeroNode { public int no; public String name; public String nickname; public HeroNode next; //指向下一个节点 //构造器 public HeroNode(int no, String name, String nickname) { this.no = no; this.name = name; .
理解 Java 中的链表
mn422533的博客
11-26 234
链表是 AbstractList 类的实现，其中我们有对象的线性排序，其中每个节点有 32 个组件：对象和指向列表中下一个对象的指针。链表对象本身通常引用一个“头”节点，或链表中的第一个节点。 用例 链表对于恒定时间添加和删除元素非常有用。要添加元素，我们要做的就是将 List 中最后一个对象的指针更改为新对象。我们也可以将列表视为先进先出的数据结构，也就是“队列”。 当我们需要获取索引的特定元素时，链表可能没有那么有用，因为我们不知道它位于何处...
链表的简介
weixin_49190101的博客
04-19 2512
数据结构之链表基础知识 1 什么是链表？ 链表链表，可以理解为像自行车链一样。数据元素是一个一个串联在一起的，这一串数据形成的结构就是链表。每一个元素都可以称之为是一个节点。 2 链表有什么特性？ 非连续，非顺序 非连续非顺序指的是 在内存中，每一个节点的存储空间不是连续和顺序的，每一个节点包含两个部分，一个是存储数据元素的“数据域”，另一个是存放下一个节点地址的“指针域”。 3 链表的优缺点？ 优点： 1 如特性所说，链表对内存空间连续和顺序没有要求，所以它可以充分利用内存空间且不需要知道下一个节点的数
数据结构之链表(java语言实现)
LNsupermali的博客
12-28 3899
数据结构之链表(java语言实现)
java代码写链表_Java数据结构和算法（六）链表之如何写链表代码
weixin_34649105的博客
02-25 282
一、理解指针或引用的含义1.含义：将某个变量(对象)赋值给指针(引用)，实际上就是就是将这个变量(对象)的地址赋值给指针(引用)。2.示例：p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。二、警惕指针丢失和内存泄漏(单链表)1.插入节点在节点a和节...
Java链表的基本使用
热门推荐
lilong117194的博客
11-06 1万+
得到的
CS441课程项目5 - Java语言应用实践
1. Java语言基础：包括变量声明、数据类型、运算符、控制流程（条件语句if-else、循环语句for、while等）、函数定义和调用等。这些是编写任何Java程序的基础。 2. 面向对象编程(OOP)：Java是一种面向对象的语言，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值