java实现链表

最新推荐文章于 2024-03-05 18:08:33 发布
最新推荐文章于 2024-03-05 18:08:33 发布
阅读量795 收藏 4
点赞数 2
分类专栏： 数据结构与算法 java基础 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woai3364/article/details/128391195
版权

一、概念

链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的.

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

二、代码实现

1、首先我们创建节点类

 //双链表节点
    private static class Node<E>{
        E val;
        Node<E> next;
        Node<E> prev;
        Node(E val){
            this.val = val;
        }
    }

2、然后设置调用链表时 初始化头尾节点长度

 //构造函数初始化头尾节点
    public MyLinkedList_tow(){
        this.head = new Node<>(null);
        this.tail = new Node<>(null);
        head.next = tail;
        tail.prev = head;
        this.size = 0;

    }

3、设置头、尾节点和长度变量

     private final Node<E>head,tail;
     private int size;

4、我们在写一个数据结构时无非就是 增、删、查、改，还有一些像获取长度，判断是否为空的功能函数，我们在这添加两个检查索引是否越界函数。后续做判读就方便多了。

private boolean isElementIndex(int index){
        return index>=0 && index<size;
    }
    private boolean isPositionIndex(int index){
        return index>= 0 && index <= size;
    }
    /** 检查 index 索引位置是否可以存在元素 */
    private void checkElementIndex(int index){
        if(!isElementIndex(index)){
            throw new IndexOutOfBoundsException();
        }

    }
    /** 检查 index 索引位置是否可以添加元素 **/
    private void checkPositionIndex(int index){
        if(!isPositionIndex(index)){
            throw new IndexOutOfBoundsException();
        }
    }

5、在链表中访问一个index 位置的节点值会很困难，必须遍历链表，我们将或取index位置的节点设置一个函数。

 private Node<E> getNode(int index){
        Node<E> p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p;
    }

6、增：①public void addFirst();

                ②public void addLast();

                ③public void add(int index,E element);

 /***** 增 *****/
    public void addFirst(E e){
        Node<E> x = new Node<>(e);
        Node<E> temp = head.next;
        //head temp
        x.next = temp;
        x.prev = head;

        head.next = x;
        temp.prev = x;

        size++;

    }
    public void addLast(E e){
        Node<E> x = new Node<>(e);
        Node<E> temp = tail.prev;
        //temp tail
        x.prev = temp;
        x.next = tail;

        temp.next = x;
        tail.prev = x;
        size++;

    }
    public void add(int index,E element){
        checkPositionIndex(index);
        Node<E> p = getNode(index);
        Node<E> temp = p.prev;
        Node<E> x = new Node<>(element);//新节点
        //temp p
        x.next = p;
        x.prev = temp;

        temp.next = x;
        p.prev = x;
        size++;
    }

注意：在添加节点时，就是将两边（前后）的两个节点的prev 和 next 指向添加的那个节点，

而添加的节点的 prev 指向前面节点，next指向后面节点。

7、删：①public E removeFirst();

②public E removeLast();

③public E remove(int index,E val);

 /***** 删 *****/
    public E removeFirst(E e){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        Node<E> x = head.next;
        Node<E> temp = x.next;

        head.next = temp;
        temp.prev = head;

        x.next = x.prev = null;
        size--;
        return x.val;
    }
    public E removeLast(E e){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        Node<E> x = tail.prev;
        Node<E> temp = x.prev;

        tail.prev = temp;
        temp.next = tail;

        x.next = x.prev = null;
        size--;
        return x.val;
    }
    public E remove(int index){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        Node<E> perv = p.prev;
        Node<E> next = p.next;

        perv.next = next;
        next.prev = perv;

        p.prev = p.next = null;
        size--;
        return p.val;
    }

8、查：①public E getFirst();

②public E getLast();

③public E get(int index);

 /***** 查 *****/
    public E getFirst(){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        return head.next.val;
    }
    public E getLast(){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        return tail.prev.val;
    }
    public E get(int index){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        return p.val;
    }

9、改：①public E set(int index,E val);

 /***** 改 *****/
    public E set(int index,E element){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        E oldVal = p.val;
        p.val = element;
        return oldVal;
    }

10、大小，是否为空

 public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }

总结：①注意 size 在add或remove 后记得++或--;

②能先判断边界问题先判断，最后写方法 

package pgs0204.mylinkedlist;

import java.util.NoSuchElementException;

public class MyLinkedList_tow<E> {

    //双链表节点
    private static class Node<E>{
        E val;
        Node<E> next;
        Node<E> prev;
        Node(E val){
            this.val = val;
        }
    }
    private final Node<E>head,tail;
    private int size;
    //构造函数初始化头尾节点
    public MyLinkedList_tow(){
        this.head = new Node<>(null);
        this.tail = new Node<>(null);
        head.next = tail;
        tail.prev = head;
        this.size = 0;

    }
    /***** 增 *****/
    public void addFirst(E e){
        Node<E> x = new Node<>(e);
        Node<E> temp = head.next;
        //head temp
        x.next = temp;
        x.prev = head;

        head.next = x;
        temp.prev = x;

        size++;

    }
    public void addLast(E e){
        Node<E> x = new Node<>(e);
        Node<E> temp = tail.prev;
        //temp tail
        x.prev = temp;
        x.next = tail;

        temp.next = x;
        tail.prev = x;
        size++;

    }
    public void add(int index,E element){
        checkPositionIndex(index);
        Node<E> p = getNode(index);
        Node<E> temp = p.prev;
        Node<E> x = new Node<>(element);//新节点
        //temp p
        x.next = p;
        x.prev = temp;

        temp.next = x;
        p.prev = x;
        size++;
    }
    /***** 删 *****/
    public E removeFirst(E e){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        Node<E> x = head.next;
        Node<E> temp = x.next;

        head.next = temp;
        temp.prev = head;

        x.next = x.prev = null;
        size--;
        return x.val;
    }
    public E removeLast(E e){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        Node<E> x = tail.prev;
        Node<E> temp = x.prev;

        tail.prev = temp;
        temp.next = tail;

        x.next = x.prev = null;
        size--;
        return x.val;
    }
    public E remove(int index){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        Node<E> perv = p.prev;
        Node<E> next = p.next;

        perv.next = next;
        next.prev = perv;

        p.prev = p.next = null;
        size--;
        return p.val;
    }
    /***** 查 *****/
    public E getFirst(){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        return head.next.val;
    }
    public E getLast(){
        if(isEmpty()){
            throw new NoSuchElementException();
        }
        return tail.prev.val;
    }
    public E get(int index){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        return p.val;
    }

    /***** 改 *****/
    public E set(int index,E element){
        checkElementIndex(index);
        Node<E> p = getNode(index);
        E oldVal = p.val;
        p.val = element;
        return oldVal;
    }
    /***** 其他工具函数 *****/
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    private boolean isElementIndex(int index){
        return index>=0 && index<size;
    }
    private boolean isPositionIndex(int index){
        return index>= 0 && index <= size;
    }
    /** 检查 index 索引位置是否可以存在元素 */
    private void checkElementIndex(int index){
        if(!isElementIndex(index)){
            throw new IndexOutOfBoundsException();
        }

    }
    /** 检查 index 索引位置是否可以添加元素 **/
    private void checkPositionIndex(int index){
        if(!isPositionIndex(index)){
            throw new IndexOutOfBoundsException();
        }
    }
    private Node<E> getNode(int index){
        Node<E> p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p;
    }
}
woai3364
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA实现链表面试题
09-03
主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。
数据结构之链表(java语言实现)
LNsupermali的博客
12-28 2645
数据结构之链表(java语言实现)
Java链表数据结构原理与使用教程
最新发布
My_wife_QBL的博客
03-05 369
链表作为一种基础的数据结构，在Java中有着广泛的应用。它代表了一系列元素的集合，每个元素都指向下一个，形成一个链。在Java中，链表主要通过LinkedList类实现，而了解其原理和使用规范是提高编程能力的关键。
链表知识详解及java代码示例
m0_68871967的博客
05-23 774
这篇教学文章主要介绍了链表的基本原理和定义，以及如何使用 Java 实现链表。链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。相比于数组，链表具有动态扩展和删除节点的优势，但是访问节点的效率较低。在文章中，我们还介绍了链表的几种常见操作，包括插入节点、删除节点、查找节点等。并且均给出java示例代码。
Java浅浅实现链表
weixin_64448174的博客
05-14 994
目录 一、链表的简单理解 1、链表长什么样子？ 2、结点是什么？ 二、链表的代码实现 1、结点的构建 2、链表的构建 3.查看链表长度 4、查找是否指定元素是否在单链表当中 5、在链表中指定位置插入元素 （1）、尾部插入 （2）、头部插入 （3）、中间插入 6、在链表指定元素第一次出现的删除 （1）、尾部删除 （2）、头部删除 （3）、中间删除 7、链表的打印 （1）、打印整个链表 （2）、从给定位置开始打印链表 8、清空链表 三、总结 ...
数据结构之链表（Java实现）
Easenyang的博客
05-18 7988
数据结构中线性表的重要知识之一
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3073
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
Java实现链表
cainiaowangdake的博客
06-06 1181
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
自己实现链表的基本操作方法（详细）（Java实现）
AwwzJ_0821的博客
10-19 2454
因为链表类也实现了线性表接口的方法，所以链表的基本操作方法和顺序表一样。这里我们定义链表中的元素类型为包装类（体现对象的形式而不是基本类型）这里提前定义了 MyNode 类，其中的属性为：Long val；三个属性，一个元素值 val ，一个指向前一个结点的引用 prev，一个指向后一个结点的引用 next。在 MyLinkedList 类（自定义链表类）中实现自定义基本方法，其中包括属性 MyNode head；int size；
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3102
数据结构之单链表的实现
java实现链表操作
10-24
用java实现了数据结构中的链表，作为新手学习数据结构和java的资料。
java实现链表增删改查
01-07
用java实现链表增删改查
LinkedList:使用 Java 实现链表
06-13
链表 使用 Java 实现链表
Java数据结构篇之链表
MasterJundarj的博客
09-23 1963
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
Java手写链表
qq_45464560的博客
09-28 2034
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V73ZFeSh-1632464808641)(https://img-mid.csdnimg.cn/release/static/image/mid/ask/081087464236187.jpg “=600 #left”)]
Java数据结构--链表
weixin_56846554的博客
03-13 838
单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点由元素和指针构成。 元素表示数据元素的映象，就是存储数据的存储单元；指针指示出后继元素存储位置，就是连接每个结点的地址数据。 以结点的序列表示的线性表称作线性链表，也就是单链表，单链表是链式存取的结构。
Java实现链表数据结构
10-09
Java实现链表数据结构可以通过创建一个Node类和一个LinkedList类来实现。下面是一个简单的示例代码： ```java // Node类表示链表中的节点 class Node { int data; Node next; public Node(int data) { this....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值