数据结构之手写LInkedList

已于 2022-07-19 16:06:45 修改
阅读量182 收藏
点赞数
文章标签： 数据结构 java 链表
于 2022-07-19 15:54:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiyishiguang/article/details/125873513
版权

一：LinkedList

1.定义head节点，用于存放头节点信息

   /**
     * head用于存放头节点信息
     */
    private Node head;

2.定义size，用于表示链表长度

   /**
     * 链表的长度
     */
    private Integer size = 0;

3.定义Node对象，用于表示某个节点的所有属性

class Node {
        //存放数据
        E data;
        //前继节点
        Node next;
        //后继节点
        Node prev;
        //构造器
        public Node(E e){
            data = e;
        }
    }
  • Node用于描述表中的一个节点
  • 其中，data用于存放于元素
  • next是存放前继节点
  • prev用于存放指向其后继节点

4.将元素追加到链表的末尾

    /**
     * 将元素追加到链表的末尾
     * @param e 被添加的元素
     * @return 添加成功，返回true
     */
    public boolean add(E e){
        //将元素封装成一个节点
        Node node = new Node(e);
        //如果链表为空，则新节点就是头节点
        if(head == null){
            head = node;
            head.next = node;
            head.prev = node;
            //链表的长度加1
            size ++;
            return true;
        }
        //找到末尾节点地址
        Node last = head.prev;
        //将新节点添加到未节点后面
        last.next = node;
        node.next = head;
        head.prev = node;
        node.prev = last;
        //链表的长度加1
        size ++;
        return true;
    }

5.将元素插入到指定下标处

 /**
     * 将元素插入到指定下标处
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if( index < 0 || index > size ){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        if(index == size){
           add(e);
        }
        //将元素封装成一个节点
        Node node = new Node(e);
        Node next = getNode(index);
        Node prev = next.prev;
        next.prev = node;
        node.prev = prev;
        prev.next = node;
        node.next = next;
        if(index == 0){
            head = node;
        }
        size ++;
    }

6.返回指定位置的节点

   /**
     * 返回指定位置的节点
     * @param index
     * @return
     */
    private Node getNode(Integer index) {
        //从头结点开始遍历
        Node node = this.head;
        //此时可以用移位运算
        //为了提升性能，可以通过比较index与链表的长度的一半来决定是向前遍历还是向后遍历
        if (index < size >>1){
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        } else {
            for (int i = size; i > index ; i--) {
                node = node.prev;
            }
        }
        return node;
    }

7.移除指定位置处的元素

   /**
     * 移除指定位置处的元素
     * @return
     */
    public E remove(Integer index){
        if(index < 0||index >=size){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        //如果链表只有一个元素,则删除该节点以后，需要将head设置为null,并返回删除的元素
        if (size == 1) {
            E data = head.data;
            head = null;
            size --;
            return data;
        }
        //找到要删除的节点
        Node node = this.getNode(index);
        //找到该节点的前驱节点和后继节点
        Node next = node.next;
        Node prev = node.prev;
        //将该节点删除(其实就是在prev和next之间建立引用关系)
        prev.next = next;
        next.prev = prev;
        //如果被删除的元素为头节点,则其下一个节点为头节点
        if(index == 0){
            head = next;
        }
        //链表长度减1
        size--;
        return node.data;
    }

8.重写toString方法

@Override
    public String toString(){
        if(head == null){
            return "[]";
        }
        StringBuilder stringBuilder = new StringBuilder("[");
        stringBuilder.append(head.data);
        Node node = head.next;
        while(node.next != head){
            stringBuilder.append("," + node.data);
            //继续查找下个节点
            node = node.next;
        }
        return stringBuilder.append("]").toString();
    }

9.源码在此

package com.sysg.list;
/**
 * @author 77916
 * 测试linkedList
 */
public class LinkedList<E> {
    /**
     * head用于存放头节点信息
     */
    private Node head;
    /**
     * 链表的长度
     */
    private Integer size = 0;

    /**
     *  Node用于描述表中的一个节点
     *  其中，data用于存放于元素
     *  next是存放前继节点
     *  prev用于存放指向其后继节点
     */
    class Node {
        //存放数据
        E data;
        //前继节点
        Node next;
        //后继节点
        Node prev;
        //构造器
        public Node(E e){
            data = e;
        }
    }

    /**
     * 将元素追加到链表的末尾
     * @param e 被添加的元素
     * @return 添加成功，返回true
     */
    public boolean add(E e){
        //将元素封装成一个节点
        Node node = new Node(e);
        //如果链表为空，则新节点就是头节点
        if(head == null){
            head = node;
            head.next = node;
            head.prev = node;
            //链表的长度加1
            size ++;
            return true;
        }
        //找到末尾节点地址
        Node last = head.prev;
        //将新节点添加到未节点后面
        last.next = node;
        node.next = head;
        head.prev = node;
        node.prev = last;
        //链表的长度加1
        size ++;
        return true;
    }

    /**
     * 将元素插入到指定下标处
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if( index < 0 || index > size ){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        if(index == size){
           add(e);
        }
        //将元素封装成一个节点
        Node node = new Node(e);
        Node next = getNode(index);
        Node prev = next.prev;
        next.prev = node;
        node.prev = prev;
        prev.next = node;
        node.next = next;
        if(index == 0){
            head = node;
        }
        size ++;
    }

    /**
     * 返回指定下标处的元素
     * @param index 下标，从0开始
     * @return 对应位置处的元素
     */
    public E get(Integer index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        Node node = getNode(index);
        //返回该节点存放的数据
        return node.data;
    }

    /**
     * 移除指定位置处的元素
     * @return
     */
    public E remove(Integer index){
        if(index < 0||index >=size){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        //如果链表只有一个元素,则删除该节点以后，需要将head设置为null,并返回删除的元素
        if (size == 1) {
            E data = head.data;
            head = null;
            size --;
            return data;
        }
        //找到要删除的节点
        Node node = this.getNode(index);
        //找到该节点的前驱节点和后继节点
        Node next = node.next;
        Node prev = node.prev;
        //将该节点删除(其实就是在prev和next之间建立引用关系)
        prev.next = next;
        next.prev = prev;
        //如果被删除的元素为头节点,则其下一个节点为头节点
        if(index == 0){
            head = next;
        }
        //链表长度减1
        size--;
        return node.data;
    }
    /**
     * 获得链表的长度
     * @return
     */
    public int size(){
        return size;
    }
    @Override
    public String toString(){
        if(head == null){
            return "[]";
        }
        StringBuilder stringBuilder = new StringBuilder("[");
        stringBuilder.append(head.data);
        Node node = head.next;
        while(node.next != head){
            stringBuilder.append("," + node.data);
            //继续查找下个节点
            node = node.next;
        }
        return stringBuilder.append("]").toString();
    }

    /**
     * 返回指定位置的节点
     * @param index
     * @return
     */
    private Node getNode(Integer index) {
        //从头结点开始遍历
        Node node = this.head;
        //此时可以用移位运算
        //为了提升性能，可以通过比较index与链表的长度的一半来决定是向前遍历还是向后遍历
        if (index < size >>1){
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        } else {
            for (int i = size; i > index ; i--) {
                node = node.prev;
            }
        }
        return node;
    }

}
随意石光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
手写一个LinkedList
Windsearcher的博客
08-27 139
LinkedList的底层是基于双向链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。 package com.liqiang.jdk; /** * 1.LinkedList的简单实现 * 2.后续有时间会逐步添加方法 * 3.实现的方法有： * void add(Object obj) * void add(int in...
LinkedList源码分析
qq2835483738的博客
06-11 140
链表 链表的介绍 手写单链表&双链表 LinkedList 源码阅读 LinkedList 并发修改异常 LinkedList 多线程安全问题的产生和解决 常见算法题 用两个链表实现栈 一、ArrayList引发的思考 优点：查询快 缺点 ​ 1、增删慢，消耗cpu的性能 ​ 情况一、指定索引上的添加 ​ 情况二、如果原数组中的元素已经不够了 ​ 2、比较浪费内存空间 有没有
java 语言之手写 LinkedList 底层源码~
最新发布
m0_70985211的博客
03-18 190
4）是基于链表实现的，因此插入删除效率高（但是如果使用时根据下标来删除，效率还是低），查找效率低。6）还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用。5）是基于链表实现的，因此不存在容量不足的问题，所有没有扩容的方法。3）里面的元素允许为null,允许重复。1）是双向链表实现的List。
手写LinkedList
dl674756321的博客
09-28 172
手写LinkedList class Node { Object obj; Node pre; Node next; public Node() { } public void setObj(Object obj) { this.obj = obj; } public void setPre(Node pre) { this.pre = pre; } public void setNext
LinkedList学习示例模拟堆栈与队列数据结构
09-04
主要介绍了LinkedList学习示例,模拟一个堆栈与队列数据结构,大家参考使用吧
linkedlist.zip_数据结构_C++_
08-11
基于C++的链式表的建立，插入节点，删除节点等功能。
基于C语言的数据结构-单链表linkedList
06-25
基于C语言的数据结构-单链表linkedList
LinkedList.rar_数据结构_C/C++_
08-10
数据结构中的链表，采用了一种比较基础的写法，易懂
linkedList.rar_数据结构_Visual_C++_
08-11
C++双向链表实现，数据结构的入门代码。
手写简单的LinkedList
dd53kzx的博客
07-05 166
双向链表
自定义ArrayList(三)-增加set()、get()方法
小沐CA
05-14 1239
自定义ArrayList(三) 此次增加增加set()、get()方法来操作变量，保证其严密性。 public E get(int index) { // TODO Auto-generated method stub checkRange(index); return (E)elementData[index]; } public void set(E element,int...
手写LinkedList代码
专注做咖啡的博客
11-22 226
LinkedList的原理是链表，所以定义节点，节点要有前驱后继和内容，其add、remove、get都是基于链表的遍历 package com.ykq; /** * 自己实现一个LinkedList * @author RSA * */ public class MyLinkedList { //保存链的第一个和最后一个，就能遍历整条链 private Node fir...
Java数据结构之手写LinkedList
linuxFBD的专栏
11-09 512
public class LinkedList {Node<E> first; Node<E> last;public int size; public LinkedList(){}public void add(E e){ linkLast(e); } public void change(int index,E e){ if (size<0||size<index){
链表设计与Java实现，手写LinkedList这也太清楚了吧
JavaMonsterr的博客
07-04 141
在谈链表之前，我们先谈谈我们平常编程会遇到的很常见的一个问题。如果在编程的时候，某个变量在后续编程中仍需使用，我们可以用一个局部变量来保存该值，除此之外一个更加常用的方法就是使用容器了。那什么是 容器 呢？从字面上来说就是用来装某个东西的，比如我们的杯子，就是容器。在程序设计当中我们最常见的容器就是数组了，他可以存我们想保存的东西。在编程当中我们最常见的容器如下：今天要谈到的链表在Java的 和C++的 当中就有使用到。那什么是链表呢？链表是由一个一个的节点组成的，每个节点包含两个字段，其中一个字段da
LinkedList的简单实现（手写）
L-Study
07-04 3438
LinkedList的底层是基于链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。代码：/** * 1.LinkedList的简单实现 * 2.后续有时间会逐步添加方法 * 3.实现的方法有： * void add(Object obj) * void add(int index,Object obj) *
纯手写LinkedList集合
sonwing_for的博客
08-18 623
首先说明一下，这篇文章我是从余胜军老师那里学习来的，算是一个简易版的LinkedList。这篇文章适合小白看一下，具体的要想理解就去老师的网站上看看他讲的就好了。废话不多说了，上代码： package com.liuz.list; /** * 纯手写linkedlist * @author Administrator * */ public class EasyLinkedList&l...
手写LinkedList的indexOf方法
06-06
下面是一个手写LinkedList的indexOf方法的示例代码： ```java public int indexOf(Object element) { int index = 0; Node<E> current = head; while (current != null) { if (current.data.equals(element)) {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

随意石光

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值