• 数据结构之单链表的模拟实现

      💕"你笑的次数越多越好，因为你只有用笑才能不怀恶意地消灭罪恶。"💕

    作者：Mylvzi 

     文章主要内容：数据结构之单链表的模拟实现 

    一.前言:
     

    在上个顺序表的博客结尾针对ArrayList的缺陷留了一个思考题

    大家可以去再看一下顺序表这篇博客https://blog.csdn.net/Mylvzi/article/details/133896470?spm=1001.2014.3001.5501

      因为ArrayList的底层是一段连续内存的空间，进行插入/删除操作的开销很大，因此ArrayList不适合用于"需要大量添加/删除数据的场景"，因此Java中又引入了LinkedList，即链表结构

    二.链表

    1.链表的概念及结构

      链表是物理地址不连续的线性表，逻辑顺序是通过"链条"连接起来的

    可以将链表想象成拉着很多节车厢的火车

    注意:
    1.链表是由一个个结点(Node)组成的，每个结点都是从堆上申请的

    2.堆为每个结点分配内存地址，分配时是随机的，所以链表的物理结构是不连续的

    链表的分类:

    按照不同的性质可以有多种分类方法:

    • 按照是否有"头节点":带头和不带头
    • 按照是否循环：循环和不循环
    • 按照链表逻辑的方向：单向和双向

     

    综上，链表可分为2 * 2 * 2 = 8种，在这里我们只需重点掌握两种链表即可

    • 无头单项非循环链表  面试常考
    • 无头双向非循环链表  Java中LinkedList的底层就是一个无头双向非循环链表

    注意：这里说的"有无头节点"中的头节点不属于链表中的有效数据，他更像是一个“傀儡节点”，仅仅作为前驱使用

    三.无头单向非循环链表的实现

    1.链表的结构

    1.     // 定义结点
    2.     static class ListNode {
    3.         int val;// 结点存储的数据
    4.         ListNode next;// 保存下一个结点的地址
    5.  
    6.         public ListNode(int val) {
    7.             this.val = val;
    8.         }
    9.     }
    10.  
    11.     // 定义头节点
    12.     public ListNode head = null;

    2.链表的插入

    因为链表的物理地址并不是连续的，所以我们插入数据的位置是多样性的，总的来说可以分为三种

    • 头插法：addFirst
    • 尾插法：addLast
    • 任意位置插入：addIndex

    1.头插法

      头插法及创建一个新的结点，将此结点插入到第一个结点之前

    1.     public void addFirst(int data) {
    2.         ListNode newNode = new ListNode(data);
    3.  
    4.         // 头插法不需要考虑链表是否为空
    5.         newNode.next = head;
    6.         head = newNode;
    7.     }

    注意：

    在链表中插入/删除数据时，最重要的一点是记得保存"下一节点"，往往是先连接后面的结点，在进行其他的操作(如果不先连接后面的结点就会损失后面的所有节点火车一节车厢断开，则后面的车厢都断开了)

    2.尾插法

    尾插法即在链表的末尾添加一个新的结点

    1.     public void addLast(int data) {
    2.         ListNode newNode = new ListNode(data);
    3.         
    4.         // 如果为空  链表中没有一个节点 直接插入
    5.         if(head == null) {
    6.             head = newNode;
    7.             return;
    8.         }
    9.  
    10.         ListNode cur = head;
    11.  
    12.         // 让cur走到链表的最后一个节点
    13.         while (cur.next != null) {
    14.             cur = cur.next;
    15.         }
    16.  
    17.         cur.next = newNode;
    18.     }

    3.任意位置插入

    给指定的位置index，在指定位置插入一个节点(第一节点对应的index为0)

    1.     public void addIndex(int index,int data) {
    2.         // 先检查index是否合法
    3.         if(index < 0 || index > size()) {
    4.             throw new posOutOfBoundException(index + "位置不合法");
    5.         }
    6.  
    7.         if (index == 0) addFirst(data);
    8.         if (index == size()) addLast(data);
    9.  
    10.         // 让cur走到要删除结点的前驱节点  走index - 1步
    11.         ListNode cur = head;
    12.         for (int i = 0; i < index-1; i++) {
    13.             cur = cur.next;
    14.         }
    15.  
    16.         ListNode newNode = new ListNode(data);
    17.         newNode.next = cur.next;
    18.         cur.next = newNode;
    19.     }

    3.查找是否包含关键字key的结点

    1.     // 判断是否包含
    2.     public boolean contains(int key) {
    3.         ListNode cur = head;
    4.         while (cur != null) {
    5.             if (cur.val == key) {
    6.                 return true;
    7.             }
    8.  
    9.             cur = cur.next;
    10.         }
    11.  
    12.         return false;
    13.     }

    4.求链表的长度

    1.     // 返回长度
    2.     public int size() {
    3.         ListNode cur = head;
    4.         int cnt = 0;// 设置计数器
    5.  
    6.         while (cur != null) {
    7.             cnt++;
    8.             cur = cur.next;
    9.         }
    10.  
    11.         return cnt;
    12.     }

    5. 删除第一次出现关键字为key的节点

     要进行此删除操作，关键还是要在删除对应节点之后仍然连接之后的结点

    1.     public void remove(int key) {
    2.         if(head == null) {
    3.             throw new RuntimeException("链表为空 无法删除");
    4.         }
    5.  
    6.         if (head.val == key) {
    7.             head = head.next;
    8.             return;
    9.         }
    10.  
    11.         // 让cur走到要删除节点的前驱节点
    12.         ListNode cur = findPrevNode(key);
    13.         if(cur == null) {
    14.             System.out.println("没有你要删除的结点");
    15.             return;
    16.         }
    17.  
    18.         cur.next = cur.next.next;
    19.     }
    20.     
    21.     // 找要删除结点的前驱结点
    22.     private ListNode findPrevNode(int key) {
    23.         ListNode cur = head;
    24.         while (cur != null) {
    25.             if (cur.next.val == key) {
    26.                 return cur;
    27.             }
    28.             cur = cur.next;
    29.         }
    30.  
    31.         return null;
    32.     }

    6.删除所有值为key的节点

    1.     public void removeAll(int key) {
    2.         if(head == null) {
    3.             throw new RuntimeException("链表为空 无法删除");
    4.         }
    5.  
    6.         // 处理头节点是key的情况
    7.         while (head.val == key) {
    8.             head = head.next;
    9.         }
    10.  
    11.         // 设置两个结点 前驱节点prev  和用于遍历的结点cur
    12.         ListNode prev = head;
    13.         ListNode cur = head.next;
    14.  
    15.         while (cur != null) {
    16.             
    17.             // 等于  进行删除
    18.             if (cur.val == key) {
    19.                 prev.next = cur.next;
    20.                 cur = cur.next;
    21.  
    22.                 continue;
    23.             }
    24.  
    25.             prev = prev.next;
    26.             cur = cur.next;
    27.         }
    28.  
    29.     }

    注意考虑当头节点是要删除的结点 

    7.链表的打印

    1.     // 打印链表
    2.     public void display() {
    3.         // 要始终保持head结点是头节点  此处使用一个临时结点cur用于遍历整个链表
    4.         ListNode cur = head;
    5.         while (cur != null) {
    6.             System.out.print(cur.val);
    7.             cur = cur.next;
    8.         }
    9.     }

     四.LinkedList

    1.什么是LinkedList

      LinkedList是Java中使用双向链表实现的一中数据结构，每个节点都含有三个属性:

    • elem:存储元素的值
    • next：保存当前节点的下一个结点
    • prev：保存当前结点的上一个结点

    在集合框架中，LinkedList也实现了List接口

    说明：

    1.LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问

    2.LinkedList适合用于大量进行数据增加/删除的操作

    2.LinkedList的模拟实现

    1.LinkedList的结构

    LinkedList是一个双向的链表，且有两个"标记结点"head，last，分别用于标记链表的头/尾

    2.代码实现 

    1. public class MyLinkedList {
    2.  
    3.     static class ListNode {
    4.         private int data;
    5.         private ListNode prev;
    6.         private ListNode next;
    7.  
    8.         public ListNode(int data) {
    9.             this.data = data;
    10.         }
    11.     }
    12.  
    13.     public ListNode head;
    14.     public ListNode last;
    15.  
    16.     /**
    17.      * 前三个方法和prev没关系
    18.      * 只需遍历整个链表即可
    19.      * @return
    20.      */
    21.  
    22.     //得到单链表的长度
    23.     public int size(){
    24.         int cnt = 0;
    25.         ListNode cur = head;
    26.         while (cur != null) {
    27.             cnt++;
    28.             cur = cur.next;
    29.         }
    30.  
    31.         return cnt;
    32.     }
    33.  
    34.     // 打印链表
    35.     public void display(){
    36.         ListNode cur = head;
    37.         while (cur != null) {
    38.             System.out.print(cur.data + " ");
    39.             cur = cur.next;
    40.         }
    41.         System.out.println();
    42.     }
    43.  
    44.     //查找是否包含关键字key是否在单链表当中
    45.     public boolean contains(int key){
    46.         ListNode cur = head;
    47.         while (cur != null) {
    48.             if (cur.data == key) {
    49.                 return true;
    50.             }
    51.             cur = cur.next;
    52.         }
    53.  
    54.         System.out.println("链表不包含该元素");
    55.         return false;
    56.     }
    57.  
    58.  
    59.     //头插法
    60.     public void addFirst(int data){
    61.         ListNode node = new ListNode(data);
    62.  
    63.         // 为空，直接赋值
    64.         if (head == null) {
    65.             head = last = node;
    66.         }else {
    67.             node.next = head;
    68.             head.prev = node;
    69.             head = node;
    70.         }
    71.  
    72.     }
    73.  
    74.     //尾插法  最方便的一集  因为本来就有尾结点
    75.     public void addLast(int data){
    76.         ListNode node = new ListNode(data);
    77.  
    78.         // 为空，直接赋值
    79.         if (head == null) {
    80.             head = last = node;
    81.         }else {
    82.            last.next = node;
    83.            node.prev = last;
    84.            last = node;
    85.         }
    86.  
    87.  
    88.     }
    89.     //任意位置插入,第一个数据节点为0号下标
    90.     public void addIndex(int index,int data){
    91.         if(index<0 || index>size()) {
    92.             throw new RuntimeException(index + "位置异常");
    93.         }
    94.  
    95.         if (index == 0) {
    96.             addFirst(data);
    97.             return;
    98.         }
    99.         if(index == size()){
    100.             addLast(data);
    101.             return;
    102.         }
    103.  
    104.         ListNode cur = searchIndex(index);
    105.         ListNode node  = new ListNode(data);
    106.  
    107.  
    108.         // 插入  对于单链表来说需要cur走到Index位置的前一个结点  而双向链表不需要  直接走到index位置的结点即可
    109.         // 在index位置的插入都是先绑定后面的
    110.         node.next = cur;
    111.         cur.prev.next = node;
    112.  
    113.         // 这两行的顺序不能改变
    114.         node.prev = cur.prev;
    115.         cur.prev = node;
    116.  
    117.     }
    118.  
    119.     private ListNode searchIndex(int index) {
    120.         ListNode cur = head;
    121.         while (index > 0) {
    122.             cur = cur.next;
    123.             index--;
    124.         }
    125.  
    126.         return cur;
    127.     }
    128.  
    129.  
    130.     /**
    131.      * 我写的这个删除的代码将寻找data==Key的这个过程封装成一个方法  思路很好  但是不利于写删除所有的key值的方法
    132.      * 因为想要删除所有的key值，不可避免的是要遍历整个链表，而不是得到某一个节点
    133.      * @param key
    134.      * @return
    135.      */
    136.  
    137.  
    138. /*    //删除第一次出现关键字为key的节点
    139.     public void remove(int key){
    140.         // 不能这样写，因为要求的是删除第一次出现的key
    142. //        if(last.data == key) {
    143. //            last = last.prev;
    144. //            last.next = null;
    145. //            return;
    146. //        }
    147.         // 使cur为data为key的结点
    148.         ListNode cur = findIndexOf(key);
    149.         if (cur == null) {
    150.             System.out.println("没有你要删除的结点");
    151.             return;
    152.         }
    154.         if (cur == head) {
    155.             head = head.next;
    156.             if (head != null) {
    157.                 head.prev = null;
    158.             }else {
    159.                 // 处理只有一个结点的情况  head直接为空了  此时只需把last也置空即可
    160.                 last = null;
    161.             }
    162.         }else {
    163.             // 处理中间结点和尾巴结点  尾巴结点要单独处理（后继为null）
    164.             if (cur.next != null) {
    165.                 cur.prev.next = cur.next;
    166.                 cur.next.prev = cur.prev;
    167.             }else {
    168.                 cur.prev.next = null;
    169.                 last = cur.prev;
    170.             }
    172.         }
    173.     }
    175.     private ListNode findIndexOf(int key) {
    176.         ListNode cur = head;
    177.         while (cur != null) {
    178.             if (cur.data == key) {
    179.                 return cur;
    180.             }
    182.             cur = cur.next;
    183.         }
    185.         return null;
    186.     }*/
    187.  
    188.     /**
    189.      * 重写remove方法
    190.      * @param key
    191.      * @return
    192.      */
    193.  
    194.     public void remove(int key) {
    195.         ListNode cur = head;
    196.  
    197.         while (cur != null) {
    198.             if (cur.data == key) {
    199.                 // 等于key也要分两种情况
    200.                 if (cur == head) {
    201.                     head = head.next;
    202.                     if (head == null) {
    203.                         last = null;
    204.                     }else {
    205.                         head.prev = null;
    206.                     }
    207.                 }else {
    208.                     // 处理中间结点和尾结点
    209.                     if (cur.next != null) {
    210.                         cur.prev.next = cur.next;
    211.                         cur.next.prev = cur.prev;
    212.                     }else {
    213.                         cur.prev.next = null;
    214.                         last = cur.prev;
    215.                     }
    216.                 }
    217.  
    218.                 return;
    219.             }else {
    220.                 cur = cur.next;
    221.             }
    222.         }
    223.  
    224.     }
    225.     //删除所有值为key的节点
    226.     public void removeAllKey(int key){
    227.         ListNode cur = head;
    228.  
    229.         while (cur != null) {
    230.             if (cur.data == key) {
    231.                 // 等于key也要分两种情况
    232.                 if (cur == head) {
    233.                     head = head.next;
    234.                     if (head == null) {
    235.                         last = null;
    236.                     }else {
    237.                         head.prev = null;
    238.                     }
    239.                 }else {
    240.                     // 处理中间结点和尾结点
    241.                     if (cur.next != null) {
    242.                         cur.prev.next = cur.next;
    243.                         cur.next.prev = cur.prev;
    244.                     }else {
    245.                         cur.prev.next = null;
    246.                         last = cur.prev;
    247.                     }
    248.                 }
    249.                 cur = cur.next;
    250.  
    251.                 //return;
    252.             }else {
    253.                 cur = cur.next;
    254.             }
    255.         }
    256.  
    257.     }
    258.  
    259.     public void clear(){
    260.         ListNode cur = head;
    261.         while (cur != null) {
    262.             ListNode curNext = cur.next;
    263.  
    264.             cur.prev = null;
    265.             cur.next = null;
    266.  
    267.             cur = cur.next;
    268.         }
    269.  
    270.         // 头尾结点要单独置空
    271.         head = null;
    272.         last = null;
    273.  
    274.  
    275.  
    276.  
    277.  
    278. //        // 把每一个链表都指控
    279. //        ListNode cur = head;
    280. //        while (cur != null) {
    281. //            cur.prev = null;
    282. //            cur = cur.next;
    283. //            if (cur != null) {
    284. //                cur.prev.next = null;
    285. //            }
    286. //        }
    287.     }
    288.  
    289. }

    3.LinkedList的使用

    1.构造方法
    • LinkedList() 无参构造
    • public LinkedList(Collection c) 使用其他集合容器中元素构造List
    1.     // 无参的构造方法
    2.     public LinkedList() {
    3.     }
    4.     
    5.     // 使用其他集合来构建一个链表
    6.     public LinkedList(Collection c) {
    7.         this();// 调用上面的构造方法
    8.         addAll(c);// 将集合c中的所有元素填入到创建的链表中
    9.     }
    2.其他方法
    1.add

    boolean add(E e) 尾插 e

    1.     // This method is equivalent to addLast. 这个方法和addLast是等价的
    2.     public boolean add(E e) {
    3.         linkLast(e);
    4.         return true;
    5.     }
    6.  
    7.     // 尾插
    8.     void linkLast(E e) {
    9.         final LinkedList.Node l = last;// 让l指向最后一个结点
    10.         
    11.         // 创建一个新的结点
    12.         final LinkedList.Node newNode = new LinkedList.Node<>(l, e, null);
    13.         last = newNode;
    14.         if (l == null)
    15.             first = newNode;
    16.         else
    17.             l.next = newNode;
    18.         size++;
    19.         modCount++;// 用于记录集合被修改的次数
    20.     }

     void add(int index, E element) 将 e 插入到 index 位置

    1.     public void add(int index, E element) {
    2.         checkPositionIndex(index);// 检查index是否合法
    3.  
    4.         // 尾插
    5.         if (index == size)
    6.             linkLast(element);
    7.         else
    8.             linkBefore(element, node(index));
    9.     }
    10.  
    11.     // Inserts element e before non-null Node succ.  在succ之前添加一个非空的结点e
    12.     void linkBefore(E e, LinkedList.Node succ) {
    13.         // assert succ != null;
    14.         
    15.         // 设置pred为succ的前驱节点
    16.         final LinkedList.Node pred = succ.prev;
    17.         final LinkedList.Node newNode = new LinkedList.Node<>(pred, e, succ);
    18.         succ.prev = newNode;
    19.         if (pred == null)
    20.             first = newNode;
    21.         else
    22.             pred.next = newNode;
    23.         size++;
    24.         modCount++;
    25.     }

    boolean addAll(Collection c) 尾插 c 中的元素

    1.     public boolean addAll(Collection c) {
    2.         return addAll(size, c);
    3.     }
    4.     
    5.     
    6.     public boolean addAll(int index, Collection c) {
    7.         checkPositionIndex(index);
    8.         
    9.         // 将集合c转变为数组  并求出他的长度
    10.         Object[] a = c.toArray();
    11.         int numNew = a.length;
    12.         if (numNew == 0)
    13.             return false;
    14.  
    15.         LinkedList.Node pred, succ;
    16.         
    17.         
    18.         if (index == size) {
    19.             // 对list进行尾插集合c
    20.             succ = null;
    21.             pred = last;
    22.         } else {
    23.             // 在指定位置的list中进行c集合的插入
    24.             succ = node(index);
    25.             pred = succ.prev;
    26.         }
    27.         
    28.         // 遍历集合  进行插入
    29.         for (Object o : a) {
    30.             @SuppressWarnings("unchecked") E e = (E) o;
    31.             LinkedList.Node newNode = new LinkedList.Node<>(pred, e, null);
    32.             if (pred == null)
    33.                 first = newNode;
    34.             else
    35.                 pred.next = newNode;
    36.             pred = newNode;
    37.         }
    38.         
    39.         // 将新加入的结点和原来的结点连接起来
    40.         if (succ == null) {
    41.             // 此处处理的是尾插
    42.             last = pred;
    43.         } else {
    44.             // 处理在指定位置的插入
    45.             pred.next = succ;
    46.             succ.prev = pred;
    47.         }
    48.  
    49.         size += numNew;
    50.         modCount++;
    51.         return true;
    52.     }
    53.
    2.remove

     E remove(int index) 删除 index 位置元素

    1.     public E remove(int index) {
    2.         checkElementIndex(index);
    3.         return unlink(node(index));
    4.     }
    5.  
    6.     E unlink(LinkedList.Node x) {
    7.         // assert x != null;
    8.         final E element = x.item;
    9.         final LinkedList.Node next = x.next;
    10.         final LinkedList.Node prev = x.prev;
    11.         
    12.         // 先处理x.prev
    13.         if (prev == null) {
    14.             // 要删除的结点为头结点  直接让x的下一个结点作为头结点
    15.             first = next;
    16.         } else {
    17.             // 不是头结点  连接x的下一个节点
    18.             prev.next = next;
    19.             x.prev = null;
    20.         }
    21.         
    22.         // 处理x.next
    23.         if (next == null) {
    24.             // 要删除的结点是尾结点
    25.             last = prev;
    26.         } else {
    27.             next.prev = prev;
    28.             x.next = null;
    29.         }
    30.  
    31.         x.item = null;
    32.         size--;
    33.         modCount++;
    34.         return element;
    35.     }

    以下操作都十分简单，读者可自行查阅使用，这里不做过多的介绍 

    3.get

    E get(int index) 获取下标 index 位置元素

    4.set

     E set(int index, E element) 将下标 index 位置元素设置为 element

    5.contains

     boolean contains(Object o) 判断 o 是否在线性表中

    6.indexOf

    int indexOf(Object o) 返回第一个 o 所在下标 

    7.subList

     List subList(int fromIndex, int toIndex) 截取部分 list

     3. LinkedList的遍历

    LinkedList的遍历的遍历一般有两种遍历方式

    • 迭代器
    • for each循环
    1.     public static void main(String[] args) {
    2.         LinkedList list = new LinkedList<>();
    3.         list.add(1); // add(elem): 表示尾插
    4.         list.add(2);
    5.         list.add(3);
    6.         list.add(4);
    7.         list.add(5);
    8.         list.add(6);
    9.         list.add(7);
    10.  
    11.         // for each循环遍历
    12.         for (Integer i : list) {
    13.             System.out.print(i + " ");
    14.         }
    15.  
    16.         // 迭代器
    17.         Iterator iterator = list.iterator();
    18.         while(iterator.hasNext()){
    19.             System.out.println(iterator.next());
    20.         }
    21.     }

    五. ArrayList和LinkedList的区别

    1. 存储空间：ArrayList物理地址连续        LinkedList物理地址不连续
    2. 随机访问(RandomAccess接口)：ArrayList支持随机访问    LinkedList不支持
    3. 头插：ArrayList需要挪动数据    LinkedList不需要挪动数据
    4. 扩容：ArrayList空间不够需要使用grow进行1.5倍扩容    LinkedList没有容量的概念
    5. 应用场景：ArrayList频繁的查询    LinkedList频繁的进行数据的删除/插入
  • 相关阅读:
    Python中的变量是什么类型？
    牛哇！MySQL中的日志“binlog”的三种格式这么好玩
    拼多多笔试
    当老板一定要学会花钱去赚钱
    基于Springboot的租房网站
    【数据结构】—— 队列基础知识以及数组模拟队列的分析、演示及优化
    Simple WPF: WPF 透明窗体和鼠标事件穿透
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver报错
    数据仓库模式之详解 Inmon 和 Kimball
    GaussDB数据库SQL系列-LOCK TABLE
  • 原文地址：https://blog.csdn.net/Mylvzi/article/details/133896432