一、实现get方法

1、一般思维实现思路

  • 1)、将对象的值放入一个中间变量中。
  • 2)、遍历索引值，将中间量的下一个元素赋值给中间量。
  • 3)、返回中间量中的元素值。
  • 4)、示意图

  • get(2),传入角标,循环两次获取到[1]元素,如图.

2、实现思路实现

  • 1)、核心方法
  1.  /**
  2.      * 最基本的写法
  3.      *
  4.      * <p>按照角标循环元素,获取最后一个元素的值</p>
  5.      *
  6.      * <p>存在问题:效率不高</p>
  7.      *
  8.      * @param index 元素的角标
  9.      * @return 角标代表的元素
  10.      */
  11.     public Object get(int index) {
  13.         Node node = firstNode;
  15.         for (int i = 0; i < index; i++) {
  17.             node = node.next;
  18.         }
  20.         return node.elements;
  21.     }
  • 2)、测试
  1. /**
  2.  * @author liuyangos8888
  3.  */
  4. public class TestGet {
  6.     public static void main(String[] args) {
  7.         testGetBase();
  9.     }
  11.     private static void testGetBase() {
  12.         MyGetLinkedList001 myGetLinkedList001 = new MyGetLinkedList001();
  13.         myGetLinkedList001.add("A");
  14.         myGetLinkedList001.add("B");
  15.         myGetLinkedList001.add("C");
  16.         myGetLinkedList001.add("D");
  17.         myGetLinkedList001.add("E");
  18.         myGetLinkedList001.add("F");
  20.         System.out.println(myGetLinkedList001.get(4));
  21.     }
  22.  }

3、思路缺少的条件

  • 1)、判断索引范围问题
  1.         // 判断索引范围
  2.         if (index < 0 || index > size - 1) {
  3.             throw new RuntimeException("索引不合法!" + index);
  4.         }
  • 2)、查找方式的优化问题(获取第888个索引时候,效率极低,建议使用折半查找)
  1. /**
  2.      * 优化版,提高查找效率,折半判断
  3.      *
  4.      * @param index 索引角标
  5.      * @return 索引对应的值
  6.      */
  7.     public Object get1(int index) {
  9.         // 判断索引范围
  10.         if (index < 0 || index > size - 1) {
  11.             throw new RuntimeException("索引不合法!" + index);
  12.         }
  14.         Node node = null;
  16.         // size>>1 除以2
  17.         if (index <= (size >> 1)) {
  18.             node = firstNode;
  20.             for (int i = 0; i < index; i++) {
  22.                 node = node.next;
  23.             }
  24.         } else {
  25.             node = lastNode;
  27.             for (int i = size - 1; i > index; i--) {
  29.                 node = node.previous;
  30.             }
  31.         }
  33.         return node.elements;
  34.     }
  • 3)、发现的其他问题(采用此方式get时候,add需要size++)

  2.    // 不做size++,在get判断范围的时候就会出现错误
  3.    public void add(Object o) {
  4.         Node node = new Node(o);
  6.         if (firstNode == null) {
  7.             firstNode = node;
  8.         } else {
  9.             node.previous = lastNode;
  10.             node.next = null;
  11.             lastNode.next = node;
  12.         }
  14.         lastNode = node;
  16.         size++;
  17.     }

二、实现remove方法

1、一般思维实现思路

  • 1)、把前一个元素的next元素，变为next.next元素
  • 2)、把最后一个元素的previous元素，变为previous.previous元素
  • 3)、size值减少操作
  • 4)、示意图

  • 有A、B、C三个节点，以链表形式存储（如上图）

  • 现在要删除节点B，A、C不变（如上图）

  • 方法就是截断A、C跟B的连接，A和C重新建立新的连接，JAVA的实现方式就是，用对象覆盖B节点的值。

2、实现思路实现

  • 1)、核心方法

  2.  /**
  3.      * 根据索引,删除数组中元素
  4.      *
  5.      * @param index 索引角标
  6.      */
  7.     public void remove(int index) {
  9.         Node temp = getNode(index);
  11.         if (temp != null) {
  12.             Node up = temp.previous;
  13.             Node down = temp.next;
  15.             if (up != null) {
  16.                 up.next = down;
  17.             }
  19.             if (down != null) {
  20.                 down.previous = up;
  21.             }
  23.             size--;
  24.         }
  26.     }
  • 2)、测试
  1. /**
  2.  * @author liuyangos8888
  3.  */
  4. public class TestRemove {
  6.     public static void main(String[] args) {
  8.         MyGetLinkedList002 myGetLinkedList002 = new MyGetLinkedList002();
  9.         myGetLinkedList002.add("A");
  10.         myGetLinkedList002.add("B");
  11.         myGetLinkedList002.add("C");
  12.         myGetLinkedList002.add("D");
  13.         myGetLinkedList002.add("E");
  14.         myGetLinkedList002.add("F");
  16.         System.out.println(myGetLinkedList002);
  17.         myGetLinkedList002.remove(3);
  18.         System.out.println(myGetLinkedList002);
  19.         myGetLinkedList002.remove(0);
  20.         System.out.println(myGetLinkedList002);
  21.         myGetLinkedList002.remove(3);
  22.         System.out.println(myGetLinkedList002);
  24.     }
  25. }

3、思路缺少的条件

  • 1)、判断索引范围问题
  1.         // 判断索引范围
  2.         if (index < 0 || index > size - 1) {
  3.             throw new RuntimeException("索引不合法!" + index);
  4.         }
  • 2)、第一个元素删除和最后一个元素删除问题

  2.             // 删除第一个元素的时候
  3.             if (index == 0) {
  4.                 firstNode = down;
  5.             }
  7.             // 删除最后一个元素的时候
  8.             if (index == size - 1) {
  9.                 lastNode = up;
  10.             }

三、实现insert(add)方法

1、一般思维实现思路

  • 1)、获取索引的元素值,得到元素的前一个节点
  • 2)、把前节点的后一个节点设置为加入的节点
  • 3)、新节点的前一个节点设置为索引值节点的前节点
  • 4)、前一个节点的后一个节点是索引值节点
  • 5)、索引值节点的前一个节点是新节点
  • 6)、示意图

  • 有A、B、C三个节点，以链表形式存储,现在要添加D节点,到链表中.

  • 切断A、B的节点连接，A和D，D和B重新建立连接，生成新的链表

2、实现思路实现

  • 1)、核心方法
  • 方法一:

  2.     /**
  3.      * 插入一个元素在指定位置
  4.      *
  5.      * @param index 指定位置索引
  6.      * @param o     插入的元素
  7.      */
  8.     public void insert(int index, Object o) {
  10.         Node newNode = new Node(o);
  12.         // 判断范围
  13.         checkRound(index);
  15.         Node temp = getNode(index);
  17.         if (temp != null) {
  19.             // 第一个元素和最后一个元素的时候
  20.             if (index == 0 || index == size - 1) {
  21.                 temp.elements = newNode.elements;
  22.             } else {
  23.                 Node up = temp.previous;
  24.                 isNull(up == null, "前一个元素为空");
  25.                 up.next = newNode;
  26.                 newNode.previous = up;
  28.                 newNode.next = temp;
  29.                 temp.previous = newNode;
  30.             }
  31.         }
  33.     }
  • 方法二:

  2. /**
  3.      * 插入一个元素在指定位置
  4.      *
  5.      * @param index 指定位置索引
  6.      * @param o     插入的元素
  7.      */
  8.     public void insert1(int index, Object o) {
  10.         Node newNode = new Node(o);
  12.         // 判断范围
  13.         checkRound(index);
  15.         Node temp = getNode(index);
  17.         if (temp != null) {
  19.             // 第一个元素和最后一个元素的时候
  20.             if (index == 0) {
  21.                 firstNode = newNode;
  22.                 newNode.next = temp.next;
  23.             } else if (index == size - 1) {
  24.                 Node up = temp.previous;
  25.                 isNull(up == null, "前一个元素为空");
  26.                 up.next = newNode;
  27.                 newNode.previous = up;
  28.             } else {
  29.                 Node up = temp.previous;
  30.                 isNull(up == null, "前一个元素为空");
  31.                 up.next = newNode;
  32.                 newNode.previous = up;
  34.                 newNode.next = temp;
  35.                 temp.previous = newNode;
  36.             }
  37.         }
  39.     }
  • 2)、测试

  2. public class TestInsert {
  4.     public static void main(String[] args) {
  5.         MyInsertLinkedList003 myInsertLinkedList003 = new MyInsertLinkedList003();
  6.         myInsertLinkedList003.add("A");
  7.         myInsertLinkedList003.add("B");
  8.         myInsertLinkedList003.add("C");
  9.         myInsertLinkedList003.add("D");
  10.         myInsertLinkedList003.add("E");
  11.         myInsertLinkedList003.add("F");
  13.         myInsertLinkedList003.insert1(1,"G");
  15.         System.out.println(myInsertLinkedList003);
  17.     }
  18. }

3、思路缺少的条件

  • 1)、判断索引范围问题

  2.    private void checkRound(int index) {
  3.         // 判断索引范围
  4.         isNull(index < 0 || index > size - 1, "索引不合法!" + index);
  5.     }
  7.     /**
  8.      * 判断空指针问题
  9.      *
  10.      * @param b      判断条件
  11.      * @param string 抛出异常的原因
  12.      */
  13.     private void isNull(boolean b, String string) {
  14.         if (b) {
  15.             throw new RuntimeException(string);
  16.         }
  17.     }
  • 2)、第一个元素删除和最后一个元素删除问题

  2. if (temp != null) {
  4.             // 第一个元素和最后一个元素的时候
  5.             if (index == 0) {
  6.                 firstNode = newNode;
  7.                 newNode.next = temp.next;
  8.             } else if (index == size - 1) {
  9.                 Node up = temp.previous;
  10.                 isNull(up == null, "前一个元素为空");
  11.                 up.next = newNode;
  12.                 newNode.previous = up;
  13.             } else {
  14.                 Node up = temp.previous;
  15.                 isNull(up == null, "前一个元素为空");
  16.                 up.next = newNode;
  17.                 newNode.previous = up;
  19.                 newNode.next = temp;
  20.                 temp.previous = newNode;
  21.             }
  22.         }

四、实现泛型和全部代码


  2. package com.synway.test.collections.version3.finallist;
  4. import com.synway.test.collections.version3.basesimple.Node;
  6. /**
  7.  * 最终手写版,添加泛型
  8.  *
  9.  * @author liuyangos8888
  10.  */
  11. public class MyLinkedListFinal<T> {
  13.     /**
  14.      * 第一个节点
  15.      */
  16.     private Node firstNode;
  18.     /**
  19.      * 最后一个节点
  20.      */
  21.     private Node lastNode;
  23.     /**
  24.      * 链表大小
  25.      */
  26.     private int size;
  28.     /**
  29.      * 添加节点到数组中
  30.      *
  31.      * @param o 节点数据
  32.      */
  33.     public void add(T o) {
  34.         Node node = new Node(o);
  36.         if (firstNode == null) {
  37.             firstNode = node;
  38.         } else {
  39.             node.previous = lastNode;
  40.             node.next = null;
  41.             lastNode.next = node;
  42.         }
  44.         lastNode = node;
  46.         size++;
  47.     }
  49.     /**
  50.      * 根据索引,删除数组中元素
  51.      *
  52.      * @param index 索引角标
  53.      */
  54.     public void remove(int index) {
  55.         checkRound(index);
  57.         Node temp = getNode(index);
  59.         if (temp != null) {
  60.             Node up = temp.previous;
  61.             Node down = temp.next;
  63.             if (up != null) {
  64.                 up.next = down;
  65.             }
  67.             if (down != null) {
  68.                 down.previous = up;
  69.             }
  71.             // 删除第一个元素的时候
  72.             if (index == 0) {
  73.                 firstNode = down;
  74.             }
  76.             // 删除最后一个元素的时候
  77.             if (index == size - 1) {
  78.                 lastNode = up;
  79.             }
  81.             size--;
  82.         }
  84.     }
  86.     /**
  87.      * 插入一个元素在指定位置
  88.      *
  89.      * @param index 指定位置索引
  90.      * @param o     插入的元素
  91.      */
  92.     public void insert(int index, T o) {
  94.         Node newNode = new Node(o);
  96.         // 判断范围
  97.         checkRound(index);
  99.         Node temp = getNode(index);
  101.         if (temp != null) {
  103.             // 第一个元素和最后一个元素的时候
  104.             if (index == 0) {
  105.                 firstNode = newNode;
  106.                 newNode.next = temp.next;
  107.             } else if (index == size - 1) {
  108.                 Node up = temp.previous;
  109.                 isNull(up == null, "前一个元素为空");
  110.                 up.next = newNode;
  111.                 newNode.previous = up;
  112.             } else {
  113.                 Node up = temp.previous;
  114.                 isNull(up == null, "前一个元素为空");
  115.                 up.next = newNode;
  116.                 newNode.previous = up;
  118.                 newNode.next = temp;
  119.                 temp.previous = newNode;
  120.             }
  121.         }
  123.     }
  125.     /**
  126.      * 优化版,提高查找效率,折半判断
  127.      *
  128.      * @param index 索引角标
  129.      * @return 索引对应的值
  130.      */
  131.     public T get(int index) {
  132.         checkRound(index);
  134.         Node node = getNode(index);
  136.         return node != null ? (T) node.elements : null;
  137.     }
  139.     /**
  140.      * 根据角标,获取节点
  141.      *
  142.      * @param index 传入角标
  143.      * @return 获取节点
  144.      */
  145.     private Node getNode(int index) {
  146.         Node node;
  147.         // size>>1 除以2
  148.         if (index <= (size >> 1)) {
  149.             node = firstNode;
  151.             for (int i = 0; i < index; i++) {
  153.                 node = node.next;
  154.             }
  155.         } else {
  156.             node = lastNode;
  158.             for (int i = size - 1; i > index; i--) {
  160.                 node = node.previous;
  161.             }
  162.         }
  163.         return node;
  164.     }
  166.     /**
  167.      * 审核传入的角标范围是否越界
  168.      *
  169.      * @param index 传入角标
  170.      */
  171.     private void checkRound(int index) {
  172.         // 判断索引范围
  173.         isNull(index < 0 || index > size - 1, "索引不合法!" + index);
  174.     }
  176.     /**
  177.      * 判断空指针问题
  178.      *
  179.      * @param b      判断条件
  180.      * @param string 抛出异常的原因
  181.      */
  182.     private void isNull(boolean b, String string) {
  183.         if (b) {
  184.             throw new RuntimeException(string);
  185.         }
  186.     }
  188.     /**
  189.      * 获取数组中元素
  190.      *
  191.      * @return 元素数组
  192.      */
  193.     @Override
  194.     public String toString() {
  195.         StringBuilder stringBuilder = new StringBuilder();
  196.         stringBuilder.append("[");
  198.         Node temp = firstNode;
  200.         while (temp != null) {
  201.             stringBuilder.append(temp.elements).append(",");
  202.             temp = temp.next;
  203.         }
  205.         stringBuilder.setCharAt(stringBuilder.length() - 1, ']');
  207.         return stringBuilder.toString();
  208.     }
  210. }

JDK源码阅读-------自学笔记(二十四)(java.util.LinkedList 再探 自定义讲解)的更多相关文章

  1. JDK源码阅读-------自学笔记(二十五)(java.util.Vector 自定义讲解)

    Vector 向量 Vector简述 1).Vector底层是用数组实现的List 2).虽然线程安全,但是效率低,所以并不是安全就是好的 3).底层大量方法添加synchronized同步标记,sy ...

  2. JDK源码阅读-------自学笔记(一)(java.lang.Object重写toString源码)

    一.前景提要 Object类中定义有public String toString()方法,其返回值是 String 类型. 二.默认返回组成 类名+@+16进制的hashcode,当使用打印方法打印的 ...

  3. JDK源码阅读-------自学笔记(五)(浅析数组)

    一.数组基础 1.定义和特点 数组也可以看做是对象,数组变量属于引用类型,数组中每个元素相当于该队形的成员变量,数组对象存储在堆中. 2.初始化数组 常用类初始化 // 整型初始化 int[] int ...

  4. JDK源码阅读（1）_简介+ java.io

    1.简介 针对这一个版块,主要做一个java8的源码阅读笔记.会对一些在javaWeb中应用比较广泛的java包进行精读,附上注释.对于容易混淆的知识点给出相应的对比分析. 精读的源码顺序主要如下: ...

  5. element-ui Upload 上传组件源码分析整理笔记（十四）

    简单写了部分注释,upload-dragger.vue(拖拽上传时显示此组件).upload-list.vue(已上传文件列表)源码暂未添加多少注释,等有空再补充,先记下来... index.vue ...

  6. Java学习笔记二十四:Java中的Object类

    Java中的Object类 一:什么是Object类: Object类是所有类的父类,相当于所有类的老祖宗,如果一个类没有使用extends关键字明确标识继承另外一个类,那么这个类默认继承Object ...

  7. jdk源码阅读笔记-ArrayList

    一.ArrayList概述 首先我们来说一下ArrayList是什么?它解决了什么问题?ArrayList其实是一个数组,但是有区别于一般的数组,它是一个可以动态改变大小的动态数组.ArrayList ...

  8. JDK源码阅读（三）：ArraryList源码解析

    今天来看一下ArrayList的源码 目录 介绍 继承结构 属性 构造方法 add方法 remove方法 修改方法 获取元素 size()方法 isEmpty方法 clear方法 循环数组 1.介绍 ...

  9. JDK源码阅读（一）：Object源码分析

    最近经过某大佬的建议准备阅读一下JDK的源码来提升一下自己 所以开始写JDK源码分析的文章 阅读JDK版本为1.8 目录 Object结构图 构造器 equals 方法 getClass 方法 has ...

随机推荐

  1. 软件工程与UML作业2

    博客班级 https://edu.cnblogs.com/campus/fzzcxy/2018SE1 作业要求 https://edu.cnblogs.com/campus/fzzcxy/2018SE ...

  2. java注解(1)

    Java注解是附加在代码中的一些元信息,用于一些工具在编译.运行时进行解析和使用,起到说明.配置的功能.注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用.注解是Java SE5中引入的重要的语言 ...

  3. 解释器与JIT编译器

    解释器 JVM设计者们的初衷仅仅只是单纯地为了满足Java程序实现跨平台特性,因此避免采用静态编译的方式直接生成本地机器指令,从而诞生了实现解释器在运行时采用逐行解释字节码执行程序的想法. 解释器真正 ...

  4. kali一些基础工具

    目录 netcat netcat https://blog.csdn.net/fageweiketang/article/details/82833193 网络工具当中的瑞士军刀 -nc指令,nc可以 ...

  5. P4395 [BOI2003]Gem 气垫车

    树形dp 首先,我们可以考虑dp,把这个问题看成一个树的染色问题,用dp[i][j]表示以i为根节点,将树染成第i种颜色的最小代价,那么我们可以得到j的最大值是(log(maxn)/log(2)+1) ...

  6. Spring属性注入（set方式、构造函数方式、p名称空间、spel、复杂类型）

    1.set注入方式 (1)注入的为值类型(八大数据类型)的数据 配置文件: <?xml version="1.0" encoding="UTF-8"?&g ...

  7. iOS14剪切板探究，淘宝实现方法分析

    随着iOS 14的发布,剪切板的滥用也被大家所知晓.只要是APP读取剪切板内容,系统都会在顶部弹出提醒,而且这个提醒不能够关闭.这样,大家在使用APP的过程中就能够看到哪些APP使用了剪切板. 正好我 ...

  8. HTML+CSS系列:登录界面实现

    一.效果 二.具体实现 1.index.html <!DOCTYPE html> <html> <head> <meta charset="utf- ...

  9. Espruino似乎和Arduino一样

    参考:https://baike.baidu.com/item/Espruino Espruino 编辑 锁定 讨论   Espruino 是一个微处理器的 JavaScript 解释器,我们用它来创 ...

  10. JavaScript求数组中元素的最大值

    要求: 求数组[2,6,1,77,52,25,7]中的最大值. 实现思路: 声明一个保存最大元素的变量 max 默认最大值max定义为数组中的第一个元素arr[0] 遍历这个数组,把里面每个数组元素和 ...