Java学习笔记：LinkedList手写实现

最新推荐文章于 2022-10-30 21:33:06 发布
最新推荐文章于 2022-10-30 21:33:06 发布
阅读量283 收藏 1
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flying_monkey_1/article/details/107475777
版权

  本文是对高淇版Java三百集，LinkedList内容学习的记录。java中LinkedList本质是双向链表，LinkedList中包含三个属性，Node first,Node previous,int size分别记录双链表的头，尾和数据的大小。

一、LinkedList常用方法

1.1 add()方法

 public void add(int index, E element)

1.2 get()方法

public E get(int index)

1.3 set()方法

 public E set(int index, E element)

1.4 remove()方法

public E remove(int index)

二、自定义实现LinkedList功能

2.1 自定义MyNode类和MyLinkedList类

(1)MyNode类

package cn.edu.ucas.gqlearn;

/**
 * @Author: hyk
 * @Date: 2020/7/20
 * @version: 1.0
 */
public class MyNode<E> {
    MyNode<E> previous;
    E element;
    MyNode<E> next;

    public MyNode() {
    }

    public MyNode(MyNode previous, E element, MyNode next) {
        this.previous = previous;
        this.element = element;
        this.next = next;
    }
}

(2) MyLinkedList类，这里实现了add()方法并且重写了toString()方法

package cn.edu.ucas.gqlearn;

import java.util.LinkedList;

/**
 * @Author: hyk
 * @Date: 2020/7/20
 * @version: 1.0
 */
public class MyLinkedList<E> {
    private MyNode<E> first;
    private MyNode<E> last;
    private int size;

    public MyLinkedList() {
    }
    public void add(E element){
        MyNode<E> newNode = new MyNode<E>(last, element, null);
        if(last == null){
            first = newNode;
        }else{
            last.next = newNode;
        }
        last = newNode;
        size++;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        MyNode<E> tempNode = first;
        while (tempNode!=null){
            sb.append(tempNode.element + ",");
            tempNode = tempNode.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }


    public static void main(String[] args) {
        MyLinkedList<String> myLinkedList = new MyLinkedList<>();
        for (int i = 0; i < 26; i++) {
            myLinkedList.add((char)('A' + i) + "");
        }
        System.out.println(myLinkedList.toString());
    }
}

2.2 添加get()方法

package cn.edu.ucas.gqlearn;

import java.util.LinkedList;

/**
 * @Author: hyk
 * @Date: 2020/7/20
 * @version: 1.0
 */
public class MyLinkedList<E> {
    private MyNode<E> first;
    private MyNode<E> last;
    private int size;

    public MyLinkedList() {
    }
    public void add(E element){
        MyNode<E> newNode = new MyNode<E>(last, element, null);
        if(last == null){
            first = newNode;
        }else{
            last.next = newNode;
        }
        last = newNode;
        size++;
    }
    public E get(int index){
        if (index < 0 || index >= size){
            throw  new RuntimeException("索引值有误:" + index);
        }
        MyNode<E> tempNode = null;
        if (index <= (size >> 1)){
            tempNode = first;
            for (int i = 0; i < index; i++) {
                tempNode = tempNode.next;
            }
        }else{
            tempNode = last;
            for (int i = size-1; i > index; i--) {
                tempNode = tempNode.previous;
            }
        }
        return tempNode.element;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        MyNode<E> tempNode = first;
        while (tempNode!=null){
            sb.append(tempNode.element + ",");
            tempNode = tempNode.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }


    public static void main(String[] args) {
        MyLinkedList<String> myLinkedList = new MyLinkedList<>();
        for (int i = 0; i < 26; i++) {
            myLinkedList.add((char)('A' + i) + "");
        }
        System.out.println(myLinkedList.toString());
        System.out.println(myLinkedList.get(22));
    }
}

2.3 添加remove()方法

package cn.edu.ucas.gqlearn;

import java.util.LinkedList;

/**
 * @Author: hyk
 * @Date: 2020/7/20
 * @version: 1.0
 */
public class MyLinkedList<E> {
    private MyNode<E> first;
    private MyNode<E> last;
    private int size;

    public MyLinkedList() {
    }
    public void add(E element){
        MyNode<E> newNode = new MyNode<E>(last, element, null);
        if(last == null){
            first = newNode;
        }else{
            last.next = newNode;
        }
        last = newNode;
        size++;
    }
    public E get(int index){
        checkRange(index);
        MyNode<E> tempNode = getMyNode(index);
        return tempNode.element;
    }

    private void checkRange(int index) {
        if (index < 0 || index >= size){
            throw  new RuntimeException("索引值有误:" + index);
        }
    }

    private MyNode<E> getMyNode(int index) {
        MyNode<E> tempNode = null;
        if (index <= (size >> 1)){
            tempNode = first;
            for (int i = 0; i < index; i++) {
                tempNode = tempNode.next;
            }
        }else{
            tempNode = last;
            for (int i = size-1; i > index; i--) {
                tempNode = tempNode.previous;
            }
        }
        return tempNode;
    }

    public void remove(int index){
        checkRange(index);
        MyNode<E> tempNode = getMyNode(index);
        if (index == 0){
            first = first.next;
            first.previous = null;
        }else if (index == (size - 1)){
            last = last.previous;
            last.next = null;
        }else{
            tempNode.previous.next = tempNode.next;
            tempNode.next.previous = tempNode.previous;
        }
        size --;
    }
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        MyNode<E> tempNode = first;
        while (tempNode!=null){
            sb.append(tempNode.element + ",");
            tempNode = tempNode.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }


    public static void main(String[] args) {
        MyLinkedList<String> myLinkedList = new MyLinkedList<>();
        for (int i = 0; i < 26; i++) {
            myLinkedList.add((char)('A' + i) + "");
        }
        System.out.println(myLinkedList.toString());
        System.out.println(myLinkedList.get(22));

        myLinkedList.remove(2);
        System.out.println(myLinkedList.toString());

        myLinkedList.remove(0);
        System.out.println(myLinkedList.toString());

        myLinkedList.remove(23);
        System.out.println(myLinkedList.toString());
    }
}

2.4添加insert()方法

package cn.edu.ucas.gqlearn;

import java.util.LinkedList;

/**
 * @Author: hyk
 * @Date: 2020/7/20
 * @version: 1.0
 */
public class MyLinkedList<E> {
    private MyNode<E> first;
    private MyNode<E> last;
    private int size;

    public MyLinkedList() {
    }
    public void add(E element){
        MyNode<E> newNode = new MyNode<E>(last, element, null);
        if(last == null){
            first = newNode;
        }else{
            last.next = newNode;
        }
        last = newNode;
        size++;
    }
    public E get(int index){
        checkRange(index);
        MyNode<E> tempNode = getMyNode(index);
        return tempNode.element;
    }

    private void checkRange(int index) {
        if (index < 0 || index >= size){
            throw  new RuntimeException("索引值有误:" + index);
        }
    }

    private MyNode<E> getMyNode(int index) {
        MyNode<E> tempNode = null;
        if (index <= (size >> 1)){
            tempNode = first;
            for (int i = 0; i < index; i++) {
                tempNode = tempNode.next;
            }
        }else{
            tempNode = last;
            for (int i = size-1; i > index; i--) {
                tempNode = tempNode.previous;
            }
        }
        return tempNode;
    }

    public void remove(int index){
        checkRange(index);
        MyNode<E> tempNode = getMyNode(index);
        if (tempNode == null){
            System.out.println("下标异常！！！");
            return;
        }
        if (index == 0){
            first = first.next;
            first.previous = null;
        }else if (index == (size - 1)){
            last = last.previous;
            last.next = null;
        }else{
            tempNode.previous.next = tempNode.next;
            tempNode.next.previous = tempNode.previous;
        }
        size --;
    }
    public void insert(int index, E element){
        checkRange(index);
        MyNode<E> newNode = null;
        if (index == 0){
            newNode = new MyNode<>(null,element,first);
            first.previous = newNode;
            first = newNode;
        }else if (index == size -1 ){
            newNode = new MyNode<>(last,element,null);
            last.next = newNode;
            last = newNode;
        }else{
            MyNode<E> tempNode = getMyNode(index);
            newNode = new MyNode<>(tempNode.previous,element,tempNode);
            tempNode.previous.next = newNode;
            tempNode.previous = newNode;
        }
        size++;
    }
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        MyNode<E> tempNode = first;
        while (tempNode!=null){
            sb.append(tempNode.element + ",");
            tempNode = tempNode.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }


    public static void main(String[] args) {
        MyLinkedList<String> myLinkedList = new MyLinkedList<>();
        for (int i = 0; i < 26; i++) {
            myLinkedList.add((char)('A' + i) + "");
        }
        System.out.println(myLinkedList.toString());
        System.out.println(myLinkedList.get(22));

        myLinkedList.remove(2);
        System.out.println(myLinkedList.toString());

        myLinkedList.remove(0);
        System.out.println(myLinkedList.toString());

        myLinkedList.remove(23);
        System.out.println(myLinkedList.toString());

        myLinkedList.insert(0,"begin!");
        System.out.println(myLinkedList.toString());

        myLinkedList.insert(myLinkedList.size - 1, "end!");
        System.out.println(myLinkedList.toString());

        myLinkedList.insert((myLinkedList.size - 1) / 2, "medium");
        System.out.println(myLinkedList.toString());
    }
}
皮卡猴
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
利用Java手写LinkedList
weixin_45747080的博客
08-30 252
利用Java手写LinkedList 和ArrayList不同的是，LinkedList是采用链表实现的，链表的特点就是每个节点存储的是value和下个节点的地址，所以不存在类似ArrayList的扩容问题，添加节点只需要一个新的节点对象然后链表末尾指向它就可以了。参考Java官方的LinkedList实现：java.util.LinkedList。不过Java官方使用双向链表实现。 链表和节点 链表有n多个链表节点组成，每个节点存储的都是元素+下个节点的内存地址。如何得到节点中存储的元素实际上是通过从链
java软件技术文档-深入java8的集合2：LinkedList的实现原理.pdf
最新发布
11-17
《深入Java8的集合2：LinkedList的实现原理》 LinkedList是Java编程语言中实现List接口的一种数据结构，它采用双链表的方式存储元素。本文将深入解析LinkedList的内部机制，帮助开发者理解其工作原理。 首先，...
手写LinkedList实现
u012758488的博客
10-18 124
/** * 纯手写 LinkeList<br> * @param <E> */ public class LinkeList<E> { // 第一个元素 private Node first; // 最后一个元素 private Node last; // 实际存放在长度 private int size; class Node { // 上一个节点 Node prev; // 节点内容 Object object; // 下.
LinkedList的简单实现（手写）
L-Study
07-04 3452
LinkedList的底层是基于链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。代码：/** * 1.LinkedList的简单实现 * 2.后续有时间会逐步添加方法 * 3.实现的方法有： * void add(Object obj) * void add(int index,Object obj) *
JAVA（手写）简单实现ArrayList和LinkedList
Simlier的博客
11-08 818
JAVA（手写）简单实现ArrayList和LinkedList 大家都知道在java学习中list类的实现类中有ArrayList 和LinkedList，其中ArrayList是使用数组实现，而LinkedList则是用链表实现的。今天就自己去用java去简单实现一下它们。 1.ArrayList的实现 1.类必须的属性 一个object的数组 list的长度 2.基本代码 `public c...
Java-手写LinkedList集合
谢文峰的博客
03-04 349
1.linkedlist数据结构 1.1单项链表 private static class Node<E> { E item; Node<E> next; Node(E element, Node<E> next) { this.item = element; this.next = next; } } 1.2双...
Java基础 学习笔记 Markdownr版
06-27
1. 面向对象（OOP）：Java的核心是面向对象编程，它将数据和操作数据的方法封装在一起，形成类。面向对象的三大特性——封装、继承和多态，在06面向对象（上）、07面向对象（中）和08面向对象（下）中进行了详细介绍...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Java-Note:Java学习笔记
04-01
"Java学习笔记"可能涵盖了许多核心概念和高级特性，旨在帮助初学者和有经验的开发者深入理解Java语言。 1. **Java基础知识** - **变量与数据类型**：Java有八种基本数据类型，包括整型、浮点型、字符型和布尔型。...
java-demo:java学习笔记
04-06
本Java学习笔记将深入探讨Java的核心概念、语法结构以及在实际开发中的应用。 1. **基础语法** - **变量与数据类型**：Java有八种基本数据类型，包括整型、浮点型、字符型和布尔型。此外，还有引用数据类型，如类...
超详细的纯手写的LinkedList源码
qq_36594703的博客
08-01 392
public class ExtLinkedList&lt;E&gt;{ private int size;//实际长度 private Node first;//第一个节点（为了查询开始） private Node last;//最后一个节点（为了添加开始） public void add(E e){ Node node=new Node();//创建一个节点 node.obj...
java提高篇（二二）-----LinkedList
chenssy 的技术博客
01-10 308
一、概述 LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。 LinkedList实现所有可选的列表操作，并允许所有的元素包括null。 除了实现 L...
手动实现LinkedList 的add方法(1)
weixin_40072979的博客
09-28 1417
链表的结构就相当于手拉手的游戏； package com.jianshun; public class Node { Node previous; //上一个节点 Node next; //下一个节点 Object element; //元素数据 public Node(Node previous, Node next, Object element) { super(...
手写LinKedList双向链表 终于搞清了什么是链表结构
qq_33471403的博客
04-27 8369
之前对Collection这块底层实现和异同点一直模糊不清，最近手动写了个链表结构实现LinKedList ，发现很多知识还是要不断去实践，专研，才能不断提升。LinKedList 实现 List接口。链表结构图   a1,a2..都代表每个Node节点。1：新建一个自定义的节点package com.kiven.linKedList; public class Node&lt;E&gt; {...
java手动实现LinkedList，并实现删除，插入等基本操作
HXZ_CREATE的博客
07-28 834
java中的LinkedList本质上是一条双向链表，因为在学C的数据结构的时候没有实现过双向链表，借此机会来理解java中的LinkedList深层次的实现。这里本人手动实现的LinkedList中没有头节点，如果有需要，可以自己手动添加。 目录 1. 节点的结构定义 2.用尾插法增加一个节点 3.改写toString()方法 4.返回特定下标的节点 5.删除一个节点 6.插入一个节点 7.取得指定下表的节点的内容 手动分割线 ---------------------------------------
Linked List - Insert, Remove
feibafeibalala的博客
11-19 289
Main.java public class Main { public static void main(String[] args) { LinkedList206<String> lnl = new LinkedList206<>(); lnl.add("Kaipo"); lnl.add("Han"); lnl.add("Rex"); lnl...
LinkedList的模拟实现（Java实现）
X_H学Java的博客
06-13 639
LinkedList是数据结构中非常重要的内容，面试中经常靠算法题，本文对LinkedList进行模拟实现，加深对LinkedList的底层双向链表的熟悉
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2411
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
Java集合-List接口-LinkedList
baidu_38126306的博客
09-20 1085
Java集合——LinkedList 1. Java LinkedList 特性 LinkedList（链表）底层是用双向链表实现的存储。是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZNePWKr-1600610375482)(D:\JavaAno\pictures\单向链表&双向链表示例.png)] 与 A
Java学习笔记：面向对象与集合框架详解
"这是一份详尽的Java学习笔记，涵盖了从基础到高级的多个主题，包括面向对象的概念、Java平台的介绍、基本语法、面向对象的特性、数组、抽象类和接口，以及Java API组件的使用。" 在Java学习笔记中，首先介绍了面向...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值