JAVA 手动实现LinkedList

最新推荐文章于 2021-03-22 00:37:01 发布
最新推荐文章于 2021-03-22 00:37:01 发布
阅读量312 收藏
点赞数
分类专栏： JAVA 文章标签： java 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ko0491/article/details/78711847
版权

JAVA 手动实现LinkedList

节点

package com.ghg.data_structure.link;

public class Node<T> {
    /**
     * 数据
     */
    public T data;
    /**
     * 前一个
     */
    public Node pre;
    /**
     * 后一个
     */
    public Node next;


    public Node() {
        super();
    }

    /**
     * 
     * @param data 数据
     * @param pre 前一个
     */
    public Node(T data, Node pre, Node next) {
        super();
        this.data = data;
        this.pre = pre;
        this.next = next;
    }


    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

    public Node getNext() {
        return next;
    }

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

    @Override
    public String toString() {
        return data+" ";
    }
}

List接口

package com.ghg.data_structure.link;

public interface MyList<T> {

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty();

    /**
     * 大小
     * @return
     */
    public int size();

    /**
     * 添加到第一个
     * @param t
     * @return
     */
    public boolean addFirst(T t);

    /**
     * 获取第一个
     * @return
     */
    public T getFirst();

    /**
     * 添加到最后
     * @param t
     * @return
     */
    public boolean addLast(T t);

    /**
     * 获取最后一个元素
     * @return
     */
    public T getLast();

    /**
     * 添加默认添加到最后
     * @param t
     * @return
     */
    public boolean add(T t);

    /**
     * 添加到指定位置
     * @param index 索引
     * @param t 数据
     * @return
     */
    public boolean add(int index, T t);

    /**
     * 获取指定位置的元素
     * @param index 索引
     * @return
     */
    public T get(int index);


    /**
     * 移除指定元素
     * @param index
     * @return
     */
    public T remove(int index);

    /**
     * 移除第一个
     * @return
     */
    public boolean removeFirst();
    /**
     * 移除最后一个
     * @return
     */
    public boolean removeLast();

    /**
     * 是否包含
     * @param object
     * @return
     */
    public boolean contains(Object object);

    /**
     * 获取迭代器
     * @return
     */
    public MyIterator<T> iterator();
}

迭代器接口

package com.ghg.data_structure.link;

public interface MyIterator<T> {

    public boolean hasNext();

    public T next();

    public boolean hasPrevious();  

    public T previous();
}

实现

package com.ghg.data_structure.link;

import java.util.NoSuchElementException;

public class MyLinkedList<T> implements MyList<T> {

    private int size = 0;

    private Node<T> first;

    private Node<T> last;

    private int position = 0;

    public MyLinkedList() {
        this.first = null;
        this.last = null;
    }

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

    public int size() {
        return size;
    }

    public boolean addFirst(T t) {
        Node<T> f = first;

        Node<T> newNode = new Node<T>(t, null, first);

        first = newNode;

        if (f == null) {
            last = newNode;
        } else {
            f.pre = newNode;
        }
        size++;
        return true;
    }

    public T getFirst() {
        return first.data;
    }

    public boolean addLast(T t) {

        Node<T> l = last;
        Node<T> newNode = new Node<T>(t, l, null);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
        return true;
    }

    public T getLast() {
        return last.data;
    }

    public boolean add(T t) {
        return addLast(t);
    }

    public boolean add(int index, T t) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("index : " + index + " size : " + size);
        }

        if (index == size) {
            return addLast(t);
        }

        Node<T> current = first;

        for (int i = 0; i < index; i++) {
            current = current.next;
        }

        Node<T> pre = current.pre;

        Node<T> newNode = new Node<T>(t, pre, current);

        current.pre = newNode;
        /**
         * 如果没有前置元素说明是第一个
         */
        if (pre == null) {
            first = newNode;
        } else {
            pre.next = newNode;
        }

        size++;
        return true;
    }

    public T get(int index) {

        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("index : " + index + " size : " + size);
        }

        Node<T> current = first;

        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }

    @Override
    public String toString() {

        Node<T> current = first;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < size; i++) {

            sb.append(current);
            current = current.next;
        }
        return sb.toString();

    }

    public T remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("index : " + index + " size : " + size);
        }

        Node<T> current = first;

        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        /**
         * 获取当前元素的前置也后置元素,将这2个元素相连接
         */
        final Node<T> next = current.next;
        final Node<T> prev = current.pre;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
        }

        if (next == null) {
            last = prev;
        } else {
            next.pre = prev;
        }

        size--;
        return current.data;
    }

    /**
     * 移除第一个
     */
    public boolean removeFirst() {
        /**
         * 获取第一个元素
         */
        Node<T> current = first;
        /**
         * 获取第一个元素的下一个元素
         */
        Node<T> next = current.next;
        /**
         * 赋值
         */
        first = next;

        /**
         * 判断下一个是不是空,如果为空就说明是最后一个,目前只有一个元素
         */
        if (next == null) {
            last = null;
        } else {
            // 前置设置为空,因为是第一个了
            next.pre = null;
        }
        size--;
        return true;
    }

    /**
     * 移除最后个
     */
    public boolean removeLast() {
        /**
         * 获取最后一个元素
         */
        Node<T> current = last;
        /**
         * 获取最后一个的前一个元素
         */
        Node<T> pre = current.pre;
        /**
         * 赋值
         */
        last = pre;

        /**
         * 判断前置是不是空,如果为空说明第一个为NULL
         */
        if (pre == null) {
            first = null;
        } else {
            // 将最后一个元素的,后置设置为空
            pre.next = null;
        }

        size--;
        return true;
    }

    public boolean contains(Object object) {
        if (object == null) {
            return false;
        }
        int index = 0;
        for (Node<T> current = first; current.next != null; current = current.next) {
            if (object.equals(current.data)) {
                break;
            }
            index++;
        }
        System.out.println("contains  index:  " + index);
        return index > 0;
    }
/*
    *//**
     * 是否有更多
     *//*
    public boolean hasNext() {

        if (position < size) {
            return true;
        } else {
            position = 0;

            return false;
        }

    }

    *//**
     * 下一个元素
     *//*
    public T next() {

        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        return get(position++);
    }*/

    public class MyInnerIterator<T> implements MyIterator<T> {

        private MyLinkedList<T> myLinkedList;
        /**
         * 游标
         */
        private int cursor = 0;

        public MyInnerIterator(MyLinkedList<T> linkedList) {
            this.myLinkedList = linkedList;
        }

        public boolean hasNext() {
            return cursor<size;
        }

        public T next() {
            return myLinkedList.get(cursor++);
        }

        public boolean hasPrevious() {
            System.out.println("cursor  "+cursor);
            return cursor>0;
        }

        public T previous() {
            return myLinkedList.get(--cursor);
        }

    }

    /**
     * 获取迭代器
     */
    public MyIterator<T> iterator() {
        return new MyInnerIterator<T>(this);
    }

}

测试

package com.ghg.data_structure.link;

public class MyListTest1 {

    public static void main(String[] args) {

        MyLinkedList<Integer> myLinkedList = new MyLinkedList<Integer>();

        myLinkedList.addFirst(3);

        myLinkedList.addFirst(5);

        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n 获取第一个: " + myLinkedList.getFirst());
        System.out.println("\n 获取最后一个: " + myLinkedList.getLast());

        myLinkedList.addLast(9);

        myLinkedList.addLast(-1);
        System.out.println("\n 全部: " + myLinkedList.toString());
        System.out.println("\n size : " + myLinkedList.size());

        myLinkedList.addFirst(67);

        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n index : " + myLinkedList.get(1));

        myLinkedList.add(45);
        myLinkedList.add(-80);
        System.out.println("\n 全部: " + myLinkedList.toString());

        myLinkedList.add(0, 45);
        System.out.println("\n 全部: " + myLinkedList.toString());

        myLinkedList.add(8, 43);
        System.out.println("\n 全部: " + myLinkedList.toString());

        myLinkedList.add(1, 33);
        myLinkedList.add(6, 12345);
        myLinkedList.add(11, 77);
        System.out.println("\n 全部: " + myLinkedList.toString());

        myLinkedList.removeFirst();
        myLinkedList.removeFirst();
        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n size: " + myLinkedList.size());

        myLinkedList.removeLast();
        myLinkedList.removeLast();
        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n size: " + myLinkedList.size());

        System.out.println("remove :" + myLinkedList.remove(3));
        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n size: " + myLinkedList.size());
        System.out.println("\n 全部: " + myLinkedList.toString());

        System.out.println("\n contains: " + myLinkedList.contains(3));

        System.out.println("get "+myLinkedList.get(6));
        /*System.out.println("\n 全部: " + myLinkedList.hasNext());
        System.out.println("\n while ");
        while(myLinkedList.hasNext()){
            System.out.print(myLinkedList.next()+" \t");
        }*/


        //System.out.println("\n 全部: " + myLinkedList.hasNext());

        System.out.println("\n 全部: iterator================ " );

        MyIterator<Integer> iterator = myLinkedList.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next()+" \t");
        }

        MyIterator<Integer> iterator1 = myLinkedList.iterator();
        //System.out.println("\n hasnext:   "+iterator1.hasNext()+" size "+myLinkedList.size());

        System.out.println("\n next : "+iterator1.next());
        System.out.println("next : "+iterator1.next());
        System.out.println("hasPrevious : "+iterator1.hasPrevious());
        System.out.println("previous :"+iterator1.previous());
    }

}

image.png

image.png

森林森
关注
专栏目录
利用Java手写LinkedList
weixin_45747080的博客
08-30 259
利用Java手写LinkedList 和ArrayList不同的是，LinkedList是采用链表实现的，链表的特点就是每个节点存储的是value和下个节点的地址，所以不存在类似ArrayList的扩容问题，添加节点只需要一个新的节点对象然后链表末尾指向它就可以了。参考Java官方的LinkedList实现：java.util.LinkedList。不过Java官方使用双向链表实现。 链表和节点 链表有n多个链表节点组成，每个节点存储的都是元素+下个节点的内存地址。如何得到节点中存储的元素实际上是通过从链
Java手写实现HashMap
最新发布
2301_79108888的博客
09-14 441
我们将创建一个名为HashMap的类，其中包含一个构造函数，用于初始化哈希表。首先，我们定义一个数组bucket，用来存储桶的信息。在构造函数中，我们可以指定哈希表的大小，例如size。然后，我们初始化bucket数组，并将每个桶都初始化为一个空链表。这样，我们就完成了哈希表的初始化。i < size;i++) {通过本篇博客，我们了解了如何用 Java 手写一个简单的 HashMap。
Java手动实现LinkedList（底层实现）
qiaomm的个人博客
02-07 420
以下是是Java手动实现LinkedList的代码例子： 功能介绍： 自定义一个链表； 添加 和删除节点 ； 插入节点 ； 增加小的封装； 增加泛型； 具体代码如下： 新建两个class，一个是SxtLinkedList，一个是Node。 SxtLinkedList类的代码如下： /** * 自定义一个链表 添加 删除节点 插入节点 增加小的封装，增加泛型 * * @author Adm...
手动实现LinkedList
qq_35810838的博客
06-01 144
手动实现LinkedList 1.首先实现一个node类 1 package text; 2 3 4 //用来表示一个节点 5 public class Node{ 6 Node previous;//注意类型 7 Object obj; 8 Node next; 9 10 p...
java实现linklist,JAVA 手动实现LinkedList
weixin_30866939的博客
03-22 145
JAVA 手动实现LinkedList节点package com.ghg.data_structure.link;public class Node {/*** 数据*/public T data;/*** 前一个*/public Node pre;/*** 后一个*/public Node next;public Node() {super();}/**** @param data 数据* @p...
Java中LinkedList详解和使用示例_动力节点Java学院整理
08-30
3. **序列化**：LinkedList实现了Serializable接口，支持序列化操作。 4. **效率**：由于使用链表结构，LinkedList在随机访问元素时效率较低，但在插入和删除元素时效率较高。 **构造函数：** - `LinkedList()`：...
java多线程模拟队列实现排队叫号
04-15
在Java中，我们可以使用`java.util.Queue`接口及其实现类，如`LinkedList`或`ArrayDeque`来创建队列。 接下来，我们需要创建两个线程类：一个是`CustomerThread`，代表等待叫号的客户，另一个是`ServiceThread`，...
Java线考试系统，支持自动阅卷、手动阅卷、随机组卷、手动组卷等功能.zip
06-02
手动组卷则为教师提供了更大的灵活性，他们可以自由选择和排列题目，可能通过Java的GUI组件来实现这个功能，教师可以通过拖放或者搜索选择题目。 三、Java源码软件 这个系统是用Java语言开发的，这意味着它利用了...
LinkList的实现
09-25
java模拟linklist双向链表的实现
如何实现Java中一个简单的LinkedList
08-31
LinkedList与ArrayList都是List接口的具体实现类。下面将介绍如何实现一个简单的LinkedList，具有很好的参考价值，下面跟着小编一起来看下吧
LinkedList的手动实现
蜜蜂采蜜
06-19 648
上一篇我们讲解了Collection接口之List子接口中的ArrayList、Vector以及Stack的实现类，由于比较简单，不在赘述，下来我们讲解List接口之LinkedList实现类 （1）LinkedList类本质上是一个双向链表，也是单向队列，双向队列，栈的实现类； （2）LinkedList类实现了单向队列，双向队列的接口，自身也提供了栈操作的方法，链表操作的方法； （3）L
手工实现LinkedList
MADE_哒哒
01-16 265
https://blog.csdn.net/qq_40301026/article/details/86773133 参照其底层代码，按照自己的理解实现了LinkedList的一些基本功能。 如果对c和c++指针了解一下，理解起来非常快。 package cn.liu.MyLinkedList; //结点 public class Node { Node prevoius;//上一个节...
手动实现一个LinkedList链表
岁月流逝
08-24 283
前言：一切从简，本链表存放int数据，不适用泛型 一、实现思路 （1）void add()：对链表进行尾插 （2）int get(int index)：依据传入的索引，找到对应元素 （3）int remove(int index)：依据传入的索引，删除对应元素，并返回被删除的元素值 （4）int set(int index, int val)：依据传入的索引和值，将对应元素的值改为传入值，并返回修改前的值 （5）int size()：返回容器中的元素个数 二、实现步骤 1）创建一个链表的容器 先定义两个指针
java手动实现双向链表LinkedList
小范的博客
01-12 913
一、LinkedList原理介绍 LinkedList是java中重要的List集合，其内部是一个双向链的数据结构。插入和删除的效率比ArrayList高,之前手动实现的ArrayList，因为插入和删除没有数组的复制工作，如果想在下标为index位置插入元素则通过从头部或者尾部开始查找，找到index原始位置的元素，则修改原始位置index元素的Node中的上一个元素，以及元素index元素前
LinkedList的简单实现（手写）
L-Study
07-04 3479
LinkedList的底层是基于链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。代码：/** * 1.LinkedList的简单实现 * 2.后续有时间会逐步添加方法 * 3.实现的方法有： * void add(Object obj) * void add(int index,Object obj) *
手动基本实现Linkedlist集合（二）
CleanCode
12-04 176
上一篇文章讲了Linkedlist的add(),get(),toString,没有看的朋友可以去看一下：手动基本实现Linkedlist集合（一），开始后面的实现 1.添加remove(int index)，移除节点方法 解释：就是讲一个节点从链表中删除 实现：改变要删除节点的前后节点指向问题 原链表格式 删除进行的操作 简单陈述：让它前面的next，指向它的后面；让它后面的p...
Java SDK早期LinkedList类解析
在Java编程中，LinkedList类是集合框架的一部分，它实现了List接口，提供了双端链表数据结构。在SDK1.5之前，LinkedList类并未包含泛型支持。这意味着在那个版本的Java中，你可以创建一个LinkedList实例而不指定具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值