手工实现LinkedList

最新推荐文章于 2022-04-11 17:03:02 发布
最新推荐文章于 2022-04-11 17:03:02 发布
阅读量133 收藏 2
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45713173/article/details/108044456
版权

title: 手工实现LinkedList
date: 2020-08-16 12:20:03
tags: [java基础,LinkedList]

LinkedList特点和底层实现

LinkedList底层是用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。

双向链表也叫双链表，是链表的一种，他的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一盒节点开始，都可以很方便的找到所有节点。

定义节点

package cn.yishan.mycollection;

/**
* 定义节点
* @author yishan
*/
public class Node {

    Node previous; //上一个节点
    Node next; //下一个节点
    Object element; //元素数据

    public Node(Node previous, Node next, Object element) {
        this.previous = previous;
        this.next = next;
        this.element = element;
    }

    public Node(Object element) {
        this.element = element;
    }
}

手工实现LinkedList01_add方法

    package cn.yishan.mycollection;


    /**
    * 自定义一个链表
    * add方法
    * @author yishan
    */
    public class SxtLinkedList01 {

        private Node first;
        private Node last;

        private int size;

        public void add(Object obj){
            Node node = new Node(obj);

            if (first==null){
                first = node;
                last = node;
            }else{
                node.previous = last;
                node.next = null;

                last.next = node;
                last = node;
            }
        }

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

        public static void main(String[] args) {
            SxtLinkedList01 list = new SxtLinkedList01();
            list.add("a");
            list.add("b");
            list.add("c");
            System.out.println(list);
        }
    }

手工实现LinkedList02_get查询_节点遍历

    package cn.yishan.mycollection;

    /**
    * 自定义一个链表
    * 增加get方法,节点遍历
    * @author yishan
    */
    public class SxtLinkedList02 {

        private Node first;
        private Node last;

        private int size;

        public void add(Object obj){
            Node node = new Node(obj);

            if (first==null){
                first = node;
                last = node;
            }else{
                node.previous = last;
                node.next = null;

                last.next = node;
                last = node;
            }
            size++;
        }

        public Object get(int index){

            if (index<0||index>size-1){
                throw new RuntimeException("索引数字不合法："+index);
            }
            Node temp = null;
            if(index<=(size>>1)){  //size>>1相当于除以2
                temp = first;
                for (int i = 0;i<index;i++){
                    temp = temp.next;
                }
            }else {
                temp = last;
                for (int i = size-1;i>index;i--){
                    temp = temp.previous;
                }
            }
            return temp.element;

        }

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

        public static void main(String[] args) {
            SxtLinkedList02 list = new SxtLinkedList02();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
            list.add("f");

            System.out.println(list);
            System.out.println(list.get(5));
        }
    }

    package cn.yishan.mycollection;

手工实现LinkedList03_增加remove

    /**
    * 自定义一个链表
    * 增加remove
    * @author yishan
    */
    public class SxtLinkedList03 {

        private Node first;
        private Node last;

        private int size;

        public void remove(int index){
            Node temp = getNode(index);

            if (temp!=null){
                Node up = temp.previous;
                Node down = temp.next;
                if (up!=null){

                    up.next = down;
                }
                if (down!=null){

                    down.previous = up;
                }
                //被删除的元素是第一个元素时
                if (index==0){
                    first = down;
                }
                //被删除的元素时最后一个元素时
                if (index==size-1){
                    last = up;
                }

                size--;
            }
        }
        public void add(Object obj){
            Node node = new Node(obj);

            if (first==null){
                first = node;
                last = node;
            }else{
                node.previous = last;
                node.next = null;

                last.next = node;
                last = node;
            }
            size++;
        }

        public Object get(int index){

            if (index<0||index>size-1){
                throw new RuntimeException("索引数字不合法："+index);
            }

            Node temp = getNode(index);
            return temp!=null?temp.element:null;

        }

        public Node getNode(int index){
            Node temp = null;
            if(index<=(size>>1)){  //size>>1相当于除以2
                temp = first;
                for (int i = 0;i<index;i++){
                    temp = temp.next;
                }
            }else {
                temp = last;
                for (int i = size-1;i>index;i--){
                    temp = temp.previous;
                }
            }
            return temp;
        }
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("[");
            Node temp = first;
            while (temp!=null){
                sb.append(temp.element+",");
                temp=temp.next;
            }
            sb.setCharAt(sb.length()-1,']');
            return sb.toString();
        }

        public static void main(String[] args) {
            SxtLinkedList03 list = new SxtLinkedList03();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
            list.add("f");

            System.out.println(list);
            System.out.println(list.get(5));
            list.remove(5);
            System.out.println(list);
        }
    }

手工实现LinkedList04_增加插入节点

    package cn.yishan.mycollection;

    /**
    * 自定义一个链表
    * 增加插入节点
    * @author yishan
    */
    public class SxtLinkedList04 {

        private Node first;
        private Node last;

        private int size;

        public void add(int index, Object obj){

            Node newNode = new Node(obj);
            Node temp = getNode(index);

            if(temp!=null){
                Node up = temp.previous;

                up.next = newNode;
                newNode.previous = up;

                newNode.next = temp;
                temp.previous = newNode;

            }
        }

        public void remove(int index){
            Node temp = getNode(index);

            if (temp!=null){
                Node up = temp.previous;
                Node down = temp.next;
                if (up!=null){

                    up.next = down;
                }
                if (down!=null){

                    down.previous = up;
                }
                //被删除的元素是第一个元素时
                if (index==0){
                    first = down;
                }
                //被删除的元素时最后一个元素时
                if (index==size-1){
                    last = up;
                }

                size--;
            }
        }
        public void add(Object obj){
            Node node = new Node(obj);

            if (first==null){
                first = node;
                last = node;
            }else{
                node.previous = last;
                node.next = null;

                last.next = node;
                last = node;
            }
            size++;
        }

        public Object get(int index){

            if (index<0||index>size-1){
                throw new RuntimeException("索引数字不合法："+index);
            }

            Node temp = getNode(index);
            return temp!=null?temp.element:null;

        }

        public Node getNode(int index){
            Node temp = null;
            if(index<=(size>>1)){  //size>>1相当于除以2
                temp = first;
                for (int i = 0;i<index;i++){
                    temp = temp.next;
                }
            }else {
                temp = last;
                for (int i = size-1;i>index;i--){
                    temp = temp.previous;
                }
            }
            return temp;
        }
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("[");
            Node temp = first;
            while (temp!=null){
                sb.append(temp.element+",");
                temp=temp.next;
            }
            sb.setCharAt(sb.length()-1,']');
            return sb.toString();
        }

        public static void main(String[] args) {
            SxtLinkedList04 list = new SxtLinkedList04();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
            list.add("f");

            System.out.println(list);
            list.add(3,"杨");
            System.out.println(list);
        }
    }

手工实现LinkedList05_增加泛型_增加封装

    package cn.yishan.mycollection;

    /**
    * 自定义一个链表
    * 增加增加泛型，增加封装
    * @author yishan
    */
    public class SxtLinkedList05<E> {

        private Node first;
        private Node last;

        private int size;

        public void add(int index, E element){
            checkRange(index);
            Node newNode = new Node(element);
            Node temp = getNode(index);

            if(temp!=null){
                Node up = temp.previous;

                up.next = newNode;
                newNode.previous = up;

                newNode.next = temp;
                temp.previous = newNode;

            }
        }

        public void remove(int index){
            checkRange(index);
            Node temp = getNode(index);

            if (temp!=null){
                Node up = temp.previous;
                Node down = temp.next;
                if (up!=null){

                    up.next = down;
                }
                if (down!=null){

                    down.previous = up;
                }
                //被删除的元素是第一个元素时
                if (index==0){
                    first = down;
                }
                //被删除的元素时最后一个元素时
                if (index==size-1){
                    last = up;
                }

                size--;
            }
        }
        public void add(E element){

            Node node = new Node(element);

            if (first==null){
                first = node;
                last = node;
            }else{
                node.previous = last;
                node.next = null;

                last.next = node;
                last = node;
            }
            size++;
        }

        public E get(int index){
            checkRange(index);
            Node temp = getNode(index);
            return temp!=null?(E) temp.element:null;

        }

        private void checkRange(int index){
            if (index<0||index>size-1){
                throw new RuntimeException("索引数字不合法："+index);
            }
        }

        private Node getNode(int index){
            Node temp = null;
            if(index<=(size>>1)){  //size>>1相当于除以2
                temp = first;
                for (int i = 0;i<index;i++){
                    temp = temp.next;
                }
            }else {
                temp = last;
                for (int i = size-1;i>index;i--){
                    temp = temp.previous;
                }
            }
            return temp;
        }
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("[");
            Node temp = first;
            while (temp!=null){
                sb.append(temp.element+",");
                temp=temp.next;
            }
            sb.setCharAt(sb.length()-1,']');
            return sb.toString();
        }

        public static void main(String[] args) {
            SxtLinkedList05<String> list = new SxtLinkedList05<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
            list.add("f");

            System.out.println(list);
            list.add(3,"杨");
            System.out.println(list);
            System.out.println(list.get(1));
        }
    }
yishan99.github.io
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手工实现一个LinkedList类
Hsiao99的博客
03-02 172
首先定义一个节点类 每一个节点都拥有3个属性：前一个节点，后一个节点，本节点的内容 class Node{ Node previous; Node next; Object element; public Node(Node previous, Node next, Object element) { this.previous = previou...
LinkedList手工实现01
hq的博客
11-03 167
LinkedList的底层是基于链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。 LinkedList类 /** * remove方法 * add方法 * get方法 * getNode方法 * @author HQ * @e-mail ahmashq95@gmail.com * @date 2018/11/2. */ public class LinkedLis...
c++实现单链表
wangpengcsdn1的博客
03-25 370
#define _CRT_SECURE_NO_WARNINGS 1 #include #include using namespace std; typedef int dataType; struct ListNode { dataType _data; ListNode* _next; ListNode(const dataType x) :_data(x)
XorLinkedList C 实现
DarinWang的博客
06-29 146
这是我的GitHub关于XorLinkList的链接:https://github.com/Darin1123/XorLinkedList 有兴趣的话可以看一下
模拟实现 LinkedList 测试类
06-10
模拟实现 LinkedList 测试类
Java实现LinkedList
09-18
实现一个链表LinkedList,要求使用链表机构实现,并提供相应的add(Object o),remove(Object o)这两个方法.
自定义实现的LinkedList
03-05
自定义实现的ArrayList数据结构，有大量注释以及编写思路，帮助新手用Java语言来实现数据结构
C语言实现LinkedList
03-21
C语言实现LinkedList
深入剖析下ArrayList与LinkedList，让你真正运用好ArrayList，LinkedList
砥砺前行的博客
04-11 1286
集合作为一种存储数据的容器，是我们日常开发中使用最频繁的对象类型之一。JDK为开发者提供了一系列的集合类型，这些集合类型使用不同的数据结构来实现。因此，不同的集合类型，使用场景也不同。 很多同学在面试的时候，经常会被问到集合的相关问题，比较常见的有ArrayList和LinkedList的区别。 相信大部分同学都能回答上：“ArrayList是基于数组实现，LinkedList是基于链表实现。”而在回答使用场景的时候，我发现大部分同学的答案是：“ArrayList和LinkedList在新增、删除元素时
JDK 8 LinkedList 源码解析
InkGenius
04-15 291
【本文是为了梳理知识的总结性文章，总结了一些自认为相关的重要知识点，只为巩固记忆以及技术交流，忘批评指正。其中参考了很多前辈的文章，包括图片也是引用，如有冒犯，侵删。】 0存储结构 从底层实现来看，LinkedList是链表实现的，其本质是双向链表。与ArrayList相比，LinkedList的插入和删除速度更快，但是随机访问速度则很慢。LinkedList的优点在于可以将零散的内存单元通...
C++泛化双向链表
HaroldC的博客
03-07 120
泛型双向链表 双向链表（doublyLinkedList.h） /************************************************************************* > File Name : doublyLinkedList.h > Author : Harold > Mail ...
Java LinkedList的实现原理及源码解析
语文课
09-23 500
LinkedList 的介绍：
源码分析系列教程（10） - 手写LinkedList框架
阿甘兄
11-04 484
代码已上传到GitHub，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-CodeAnalysis-Demo 1.LinkedList结构原理 LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,如下： 既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点...
LinkedList源码超详细解析【不看会后悔系列】
抛弃幻想，准备斗争
10-13 409
在阅读源码之前，首先对jdk1.8版本LinkedList进行简单概括： 1.双向链表结构，真正的动态结构，不需要考虑固容问题。 2.散失了随机访问能力。 源码解析已传上github：https://github.com/NolanJcn/javautilexplain 对LinkedList与ArrayList进行比较： LinkedList的继承结构： public class LinkedL...
android组件！应聘高级Android工程师历程感言，通用流行框架大全
dajie1213的博客
03-02 485
前言 说起程序员人们的第一印象就是工资高、加班凶、话少钱多头发少。再加上现在科技互联网公司太吃香，bat、华为小米等公司程序员加班情况被广泛传播，程序员用生命在敲代码的印象刻在了很多人的心里。 与其它行业一样，凡是有高级和普通，虽然都是敲代码但也有大牛和普通之分，大牛程序员，一个人比一个团队做项目都做得快，最为出名的当属十几年前求伯君在做wps时，一个人完成了微软二十人团队没有完成的项目需求，也让wps在与微软的竞争中站稳了脚跟。程序员的能力差距真的比贫富的差距还要大。 Android面试中有哪些常见问题
C++数据结构和算法1 c++基础 枚举 结构体 抽象数据结构-类 模板函数、模板类 数组 列表 单向链表 双向链表
万有文的博客
01-16 569
C++数据结构和算法1 c++基础 枚举 结构体 抽象数据结构-类 模板函数、模板类 数组 列表 单向链表 双向链表 github 程序分析 章1 基础知识====================================== 1.1 C++基础 控制程序走向 if else结构 int i =200; if(i &amp;gt; 100) cout &amp;lt;&amp;l...
【集合】LinkedList 源码分析
yhl_jxy的博客
11-03 374
前言 Github：https://github.com/yihonglei/jdk-source-code-reading（java-collection） 一LinkedList 概述 LinkedList基于双向链表实现，主要特性： 二ListkedList 实例 三 LinkedList 底层实现 四 总结
插入排序
supermouse的博客
12-14 186
原理 插入排序是一种简单的排序算法，它将待排序的序列看作两部分，左半部分已经有序，右半部分则是乱序，初始状态下，左半部分只有一个元素，整个排序过程就是从第二个元素开始，不断地依次从右边乱序部分中取出元素，放到左边有序部分中的合适位置，直到最后右边乱序部分中的元素全部被取走，整个序列就被排好序了。 与其他高级排序算法（比如快速排序、堆排序、归并排序）相比，插入排序算法的效率低得多，但是这并不意味着它...
用C++实现LinkedList类
最新发布
07-10
当然，我可以帮你实现一个基本的LinkedList类。下面是一个简单的示例代码： ```c++ #include using namespace std; // LinkedList节点 class Node { public: int data; Node* next; Node(int value) { data...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值