devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java版的数据结构——链表_java链表操作

作者：我家小花儿 | 2024-07-14 03:47:42

赞

踩

java链表操作

目录

1.单向不带头链表

1.1 链表的概念及结构

1.2 代码部分

1.3 完整的全部代码

2. 双向不带头链表

2.1 代码部分

2.2 完整的代码

3. MySingleList与MyLinkedList代码上的区别

4. LinkedList的使用

4.1 什么是LinkedList

4.2 LinkedList的使用

4.2.1 LinkedList的构造

4.2.2 LinkedList的其他常用方法介绍

4.2.3 LinkedList的遍历

5. ArrayList和LinkedList的区别

1.单向不带头链表

1.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

类似于火车

 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

（1）单向或双向

（2）带头或者不带头

（3） 循环或者非循环

虽然有这么多的链表的结构，但是我们重点掌握两种:

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

  • 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

1.2 代码部分

不带头单向链表MySingleList

（1）包含了不带头单向链表的属性，用内部类去定义

（2）用方法定义该链表的操作

链表命名如下：

public class MySinglelist {…}

（1）用静态内部类定义节点的属性（注：Java中的引用类型的变量存储都是地址）

  1. static class ListNode{
  2.         public int val;//存储的数据
  3.         public ListNode next;//存储下一个节点的地址
  4.         //定义一个内部类的构造方法
  5.         public ListNode(int val){
  6.             this.val = val;
  7.         }
  8. }

（2）代表当前链表的头结点引用

public ListNode head;

（3）为了测试方便，先直接创建3个结点，且添加到链表中，这个方法很少用到的

  1. public void createLink(){
  2.         ListNode listNode1 = new ListNode(1);
  3.         ListNode listNode2 = new ListNode(2);
  4.         ListNode listNode3 = new ListNode(3);
  5.         ListNode listNode4 = new ListNode(4);
  6.         head = listNode1;
  7.         listNode1.next = listNode2;
  8.         listNode2.next = listNode3;
  9.         listNode3.next = listNode4;
  10. }

（4）从头开始遍历

  1.     public void display(){
  2.             if(head == null)
  3.                 return;
  4.             //创建一个变量cur来代表head移动
  5.         ListNode cur  = head;
  6.         while(cur != null){
  7.             System.out.print(cur.val + " ");
  8.             cur = cur.next;
  9.         }
  10.         System.out.println();
  11.     }

（5）从指定位置开始遍历

  1.     //从指定位置遍历
  2.     public void display(ListNode newHead){
  3.         //如果说 把整个链表 遍历完成 那么 就需要 head == null
  4.         // 如果说 你遍历到链表的尾巴  head.next == null
  5.         ListNode cur = newHead;
  6.         while(cur != null){
  7.             System.out.print(cur.val + " ");
  8.             cur = cur.next;
  9.         }
  10.         System.out.println();
  11.     }

（6）查找是否包含关键字可以是否在单链表当中

  1.     //查找是否包含关键字key是否在单链表当中
  2.     public boolean contains(int key){
  3.         ListNode cur = head;
  4.         //思路：要遍历所有节点
  5.         while(cur != null){
  6.             //然后去比较是否包含这个值，是就返回true，
  7.             if(cur.val == key)
  8.                 return true;
  9.             cur = cur.next;
  10.         }
  11.         //当跳出循环后，还没有找到key，意味着没找到，返回false
  12.         return false;
  13.     }

（7）得到单链表的长度，时间复杂度O(N)

  1.     //得到单链表的长度，时间复杂度O(N)
  2.     public int size(){
  3.         ListNode cur = head;
  4.         int count = 0;
  5.         while(cur != null){
  6.             count++;
  7.             cur = cur.next;
  8.         }
  9.         return count;
  10.     }

（8）头插法，时间复杂度O(1)

  1.     //头插法 O(1)
  2.     public void addFirst(int data){
  3.         ListNode listNode = new ListNode(data);
  4.         listNode.next = head;
  5.         head = listNode;
  6.     }

（9）尾插法，时间复杂度O(N)，注：其实就是找尾巴的过程

  1.     //尾插法 O(N)，注：就是找尾巴的过程
  2.     public void addLast(int data){
  3.         ListNode listNode = new ListNode(data);
  4.         //处理特殊情况：空表的情况，那么直接将listNode赋值给head
  5.         if(head == null){
  6.             head = listNode;
  7.             return;
  8.         }
  9.         ListNode cur = head;
  10.         while(cur != null){
  11.             cur = cur.next;
  12.         }
  13.         cur.next = listNode;
  14.     }

 （10）任意位置插入，第一个数据结点为0号下标

  1.     //任意位置插入,第一个数据节点为0号下标
  2.     public void addIndex(int index,int data){
  3.         //先检查index是否合法
  4.         chechIndex(index);
  5.         //如果是index == 0，就可以用头插法
  6.         if(index == 0){
  7.             addFirst(data);
  8.             return;
  9.         }
  10.         if(index == size()){
  11.             addLast(data);
  12.             return;
  13.         }
  14.         ListNode newListNode = new ListNode(data);
  15.         ListNode subNode = findIndexSubOne(index);
  16.         newListNode.next = subNode.next;//把原subNode后一个节点地址给newListNode的next域
  17.         subNode.next = newListNode;//把新节点接在sub后面
  18.     }
  19.  
  20.     //检查下标是否合法
  21.     //因为是类里面自己调用，所以不需要用public修饰
  22.     private void chechIndex(int index) throws ListIndexOutOfException{
  23.         if(index < 0 || index > size()){
  24.             throw new ListIndexOutOfException();
  25.         }
  26.     }
  27.  
  28.     //找到index下标的前一个节点，也就是index - 1的节点
  29.     private ListNode findIndexSubOne(int index){
  30.         ListNode cur = head;
  31.         while(index > 1){
  32.             cur = cur.next;
  33.             index--;
  34.         }
  35.         return cur;
  36.     }

（11）删除第一次出现关键字为key的节点 O(N)

  1. //删除第一次出现关键字为key的节点 O(N)
  2.     public void remove(int key){
  3.         //特殊情况：一个节点都没有
  4.         if(head == null){
  5.             return;
  6.         }
  7.         //通常情况
  8.         //首先，当我找到了key的节点，要删除该节点，需要知道上一个节点
  9.  
  10.         //如果只有一个节点且key == head.key，那么head.next = null
  11.         if(head.val == key){
  12.             head = head.next;
  13.             return;
  14.         }
  15.  
  16.         //找到删除节点的前一个节点
  17.         ListNode subNode = searchPrev(key);
  18.         //该if代码是为了防止空指针异常（当没找到key的节点就会导致空指针异常）
  19.         if(subNode == null){
  20.             return;
  21.         }
  22.         ListNode del = subNode.next;//要删除的节点
  23.         subNode.next = del.next;
  24.     }
  25.  
  26.  
  27.     //找到关键字key的前一个节点
  28.     //因为是类内自己使用，所以使用private修饰符
  29.     private ListNode searchPrev(int key){
  30.         ListNode cur = head;
  31.         while(cur.next != null){
  32.             if(cur.next.val == key)
  33.                 return cur;
  34.             cur = cur.next;
  35.         }
  36.         return null;//没有你要删除的结点，所以没有上一个节点
  37.     }

（12）删除所有值为key的节点

  1.     //删除所有制为key的节点
  2.     public void removeAllkey(int key){
  3.         if(head == null){
  4.             return;
  5.         }
  6.         ListNode prev = head;
  7.         ListNode cur = head.next;
  8.         while(cur != null){
  9.             if(cur.val == key){
  10.                 prev.next = cur.next;
  11.                 cur = cur.next;
  12.             }else{
  13.                 cur = cur.next;
  14.                 prev = prev.next;
  15.             }
  16.         }
  17.         //最后处理第一个节点
  18.         if(head.val == key){
  19.             head = head.next;
  20.         }
  21.     }

 （13）保证链表当中所有的节点，都可以被回收

  1.     /**
  2.      * 保证链表当中 所有的节点 都可以被回收
  3.      */
  4.     public void clear(){
  5.         //当head节点没有指向，其余节点都会被gc回收
  6.         head = null;
  7.     }

1.3 完整的全部代码

  1. /*
  2. 不带头单向链表
  3. MySingleList
  4. （1）包含了不带头单向链表的属性，用内部类去定义
  5. （2）用方法定义该链表的操作
  6.  */
  7.  
  8. public class MySinglelist {
  9.     //用静态内部类定义节点的属性
  10.     /*
  11.     java中的引用类型的变量存储都是地址
  12.      */
  13.     static class ListNode{
  14.         public int val;//存储的数据
  15.         public ListNode next;//存储下一个节点的地址
  16.         //定义一个内部类的构造方法
  17.         public ListNode(int val){
  18.             this.val = val;
  19.         }
  20.     }
  21.  
  22.     //代表当前链表的头结点的引用
  23.     public ListNode head;
  24.  
  25.     //创建3个节点，且添加到链表中，这个方法很少用到
  26.     public void createLink(){
  27.         ListNode listNode1 = new ListNode(1);
  28.         ListNode listNode2 = new ListNode(2);
  29.         ListNode listNode3 = new ListNode(3);
  30.         ListNode listNode4 = new ListNode(4);
  31.         head = listNode1;
  32.         listNode1.next = listNode2;
  33.         listNode2.next = listNode3;
  34.         listNode3.next = listNode4;
  35.     }
  36.  
  37.     //从头开始遍历
  38.     public void display(){
  39.             if(head == null)
  40.                 return;
  41.             //创建一个变量cur来代表head移动
  42.         ListNode cur  = head;
  43.         while(cur != null){
  44.             System.out.print(cur.val + " ");
  45.             cur = cur.next;
  46.         }
  47.         System.out.println();
  48.     }
  49.  
  50.     //从指定位置遍历
  51.     public void display(ListNode newHead){
  52.         //如果说 把整个链表 遍历完成 那么 就需要 head == null
  53.         // 如果说 你遍历到链表的尾巴  head.next == null
  54.         ListNode cur = newHead;
  55.         while(cur != null){
  56.             System.out.print(cur.val + " ");
  57.             cur = cur.next;
  58.         }
  59.         System.out.println();
  60.     }
  61.  
  62.     //查找是否包含关键字key是否在单链表当中
  63.     public boolean contains(int key){
  64.         ListNode cur = head;
  65.         //思路：要遍历所有节点
  66.         while(cur != null){
  67.             //然后去比较是否包含这个值，是就返回true，
  68.             if(cur.val == key)
  69.                 return true;
  70.             cur = cur.next;
  71.         }
  72.         //当跳出循环后，还没有找到key，意味着没找到，返回false
  73.         return false;
  74.     }
  75.  
  76.     //得到单链表的长度，时间复杂度O(N)
  77.     public int size(){
  78.         ListNode cur = head;
  79.         int count = 0;
  80.         while(cur != null){
  81.             count++;
  82.             cur = cur.next;
  83.         }
  84.         return count;
  85.     }
  86.  
  87.     //头插法 O(1)
  88.     public void addFirst(int data){
  89.         ListNode listNode = new ListNode(data);
  90.         listNode.next = head;
  91.         head = listNode;
  92.     }
  93.  
  94.     //尾插法 O(N)，注：就是找尾巴的过程
  95.     public void addLast(int data){
  96.         ListNode listNode = new ListNode(data);
  97.         //处理特殊情况：空表的情况，那么直接将listNode赋值给head
  98.         if(head == null){
  99.             head = listNode;
  100.             return;
  101.         }
  102.         ListNode cur = head;
  103.         while(cur != null){
  104.             cur = cur.next;
  105.         }
  106.         cur.next = listNode;
  107.     }
  108.  
  109.     //任意位置插入,第一个数据节点为0号下标
  110.     public void addIndex(int index,int data){
  111.         //先检查index是否合法
  112.         chechIndex(index);
  113.         //如果是index == 0，就可以用头插法
  114.         if(index == 0){
  115.             addFirst(data);
  116.             return;
  117.         }
  118.         if(index == size()){
  119.             addLast(data);
  120.             return;
  121.         }
  122.         ListNode newListNode = new ListNode(data);
  123.         ListNode subNode = findIndexSubOne(index);
  124.         newListNode.next = subNode.next;//把原subNode后一个节点地址给newListNode的next域
  125.         subNode.next = newListNode;//把新节点接在sub后面
  126.     }
  127.  
  128.     //检查下标是否合法
  129.     //因为是类里面自己调用，所以不需要用public修饰
  130.     private void chechIndex(int index) throws ListIndexOutOfException{
  131.         if(index < 0 || index > size()){
  132.             throw new ListIndexOutOfException();
  133.         }
  134.     }
  135.  
  136.     //找到index下标的前一个节点，也就是index - 1的节点
  137.     private ListNode findIndexSubOne(int index){
  138.         ListNode cur = head;
  139.         while(index > 1){
  140.             cur = cur.next;
  141.             index--;
  142.         }
  143.         return cur;
  144.     }
  145.  
  146.     //删除第一次出现关键字为key的节点 O(N)
  147.     public void remove(int key){
  148.         //特殊情况：一个节点都没有
  149.         if(head == null){
  150.             return;
  151.         }
  152.         //通常情况
  153.         //首先，当我找到了key的节点，要删除该节点，需要知道上一个节点
  154.  
  155.         //如果只有一个节点且key == head.key，那么head.next = null
  156.         if(head.val == key){
  157.             head = head.next;
  158.             return;
  159.         }
  160.  
  161.         //找到删除节点的前一个节点
  162.         ListNode subNode = searchPrev(key);
  163.         //该if代码是为了防止空指针异常（当没找到key的节点就会导致空指针异常）
  164.         if(subNode == null){
  165.             return;
  166.         }
  167.         ListNode del = subNode.next;//要删除的节点
  168.         subNode.next = del.next;
  169.     }
  170.  
  171.  
  172.     //找到关键字key的前一个节点
  173.     //因为是类内自己使用，所以使用private修饰符
  174.     private ListNode searchPrev(int key){
  175.         ListNode cur = head;
  176.         while(cur.next != null){
  177.             if(cur.next.val == key)
  178.                 return cur;
  179.             cur = cur.next;
  180.         }
  181.         return null;//没有你要删除的结点，所以没有上一个节点
  182.     }
  183.  
  184.     //删除所有制为key的节点
  185.     public void removeAllkey(int key){
  186.         if(head == null){
  187.             return;
  188.         }
  189.         ListNode prev = head;
  190.         ListNode cur = head.next;
  191.         while(cur != null){
  192.             if(cur.val == key){
  193.                 prev.next = cur.next;
  194.                 cur = cur.next;
  195.             }else{
  196.                 cur = cur.next;
  197.                 prev = prev.next;
  198.             }
  199.         }
  200.         //最后处理第一个节点
  201.         if(head.val == key){
  202.             head = head.next;
  203.         }
  204.     }
  205.  
  206.     /**
  207.      * 保证链表当中 所有的节点 都可以被回收
  208.      */
  209.     public void clear(){
  210.         //当head节点没有指向，其余节点都会被gc回收
  211.         head = null;
  212.     }
  213. }

2. 双向不带头链表

2.1 代码部分

（1）把结点包装起来，采用了内部类的方法

  1.     //把结点包装起来
  2.     static class ListNode{
  3.         public int val;
  4.         public ListNode prev;//前驱
  5.         public ListNode next;//后继
  6.  
  7.         public ListNode(int val){
  8.             this.val = val;
  9.         }
  10.     }

（2）定义指向头部和尾部的指针

  1. //定义指向头部和尾部的指针
  2.     public ListNode head;
  3.     public ListNode last;

（3）遍历整个表

  1.     public void display(){
  2.         ListNode cur = head;
  3.         while(cur != null){
  4.             System.out.println(cur.val + " ");
  5.             cur = cur.next;
  6.         }
  7.         System.out.println();
  8.     }

（4） 头插法 O(1)

  1.     //头插法 O(1)
  2.     public void addFirst(int data){
  3.         //先创建一个结点
  4.         ListNode newNode = new ListNode(data);
  5.         //判断原来是否为空表
  6.         if(head == null){
  7.             head = newNode;
  8.             last = newNode;
  9.         }else{//原表有数据，往里面添加数据
  10.             newNode.next = head;
  11.             head.prev = newNode;
  12.             head = newNode;
  13.         }
  14.     }

（5）尾插法 O(1)

  1.     //尾插法 O(1)
  2.     public void addLast(int data){
  3.         ListNode newNode = new ListNode(data);
  4.         //判断原来是否为空表
  5.         if(head == null){
  6.             head = newNode;
  7.             last = newNode;
  8.         }else{//原表有数据，往里面添加数据
  9.             last.next = newNode;
  10.             newNode.prev = last;
  11.             last = newNode;
  12.         }
  13.     }

（6）任意位置插入,第一个数据节点为0号下标

  1.     //任意位置插入,第一个数据节点为0号下标
  2.     public void addIndex(int index,int data){
  3.         //先判断index是否合法
  4.         if(index < 0 || index > size()){
  5.             throw new ListIndexOutOfException("index不合法");
  6.         }
  7.         //如果index为0，调用头插法
  8.         if(index == 0){
  9.             addFirst(data);
  10.             return;
  11.         }
  12.         //如果index为size()，调用尾插法
  13.         if(index == size()){
  14.             addLast(data);
  15.             return;
  16.         }
  17.         //在其他位置进行插入
  18.         //先找到插入结点的位置
  19.         ListNode cur = findIndex(index);
  20.         //创建一个新的结点
  21.         ListNode newNode = new ListNode(data);
  22.         //进行插入
  23.         newNode.next = cur;
  24.         cur.prev.next = newNode;
  25.         newNode.next = cur;
  26.         cur.prev = newNode;
  27.  
  28.     }

（7）找到插入结点的位置

  1.     //找到插入结点的位置
  2.     private ListNode findIndex(int index){
  3.         ListNode cur = head;
  4.         while(index > 0){
  5.             cur = cur.next;
  6.             index--;
  7.         }
  8.         return cur;
  9.     }

（8）计算大小

  1.     //计算大小
  2.     public int size(){
  3.         int count = 0;
  4.         ListNode cur = head;
  5.         while(cur != null){
  6.             count++;
  7.             cur = cur.next;
  8.         }
  9.         return count;
  10.     }

（9）查找是否包含关键字key是否在单链表当中

  1.     //查找是否包含关键字key是否在单链表当中
  2.     public boolean contains(int key){
  3.         ListNode cur = head;//作为代步滴滴
  4.         while(cur != null){
  5.             if (cur.val == key){
  6.                 return true;
  7.             }
  8.             cur = cur.next;
  9.         }
  10.         return false;
  11.     }

（10）删除第一次出现关键字为key的节点

  1.     //删除第一次出现关键字为key的节点
  2.     public void remove(int key){
  3.         ListNode cur = head;
  4.         while (cur != null){
  5.             //开始删除
  6.             if(cur.val == key){
  7.                 //1. 如果删除的是第一个结点
  8.                 if(head.val == key){
  9.                     head = head.next;
  10.                     //1.1 如果不是只有一个结点的时候
  11.                     //才可以将前驱结点做空
  12.                     if(head != null){
  13.                         head.prev = null;
  14.                     }
  15.                 }else{//2. 如果删除的是其他结点
  16.                     //中间结点
  17.                     cur.prev.next = cur.next;
  18.                     //cur.next.prev = cur.prev;cur指向的是尾结点，cur.next.prev 就会发生空指针异常
  19.                     //所以需要当不是尾结点时，才能执行这段代码
  20.                     if(cur.next != null){
  21.                         cur.next.prev = cur.prev;
  22.                     }else{//如果是尾巴结点
  23.                         last = last.prev;
  24.                     }
  25.                 }
  26.                 return;//如果是删除一个结点就多了个return
  27.             }
  28.             cur = cur.next;
  29.         }
  30.     }

（11）删除所有值为key的节点

  1.     //删除所有值为key的节点
  2.     public void removeAllKey(int key){
  3.         ListNode cur = head;
  4.         while (cur != null){
  5.             //开始删除
  6.             if(cur.val == key){
  7.                 //1. 如果删除的是第一个结点
  8.                 if(head.val == key){
  9.                     head = head.next;
  10.                     //1.1 如果不是只有一个结点的时候
  11.                     //才可以将前驱结点做空
  12.                     if(head != null){
  13.                         head.prev = null;
  14.                     }
  15.                 }else{//2. 如果删除的是其他结点
  16.                     //中间结点
  17.                     cur.prev.next = cur.next;
  18.                     //cur.next.prev = cur.prev;cur指向的是尾结点，cur.next.prev 就会发生空指针异常
  19.                     //所以需要当不是尾结点时，才能执行这段代码
  20.                     if(cur.next != null){
  21.                         cur.next.prev = cur.prev;
  22.                     }else{//如果是尾巴结点
  23.                         last = last.prev;
  24.                     }
  25.                 }
  26.             }
  27.             cur = cur.next;
  28.         }
  29.     }

（12）保证链表当中所有的节点，都可以被回收

  1. public void clear(){
  2.         /*ListNode cur = head;
  3.         while (cur != null) {
  4.             ListNode curNext = cur.next;
  5.             cur.prev = null;
  6.             cur.next = null;
  7.             cur = curNext;
  8.         }*/
  9.         head = null;
  10.         last = null;
  11.     }

2.2 完整的代码

  1.  
  2.  
  3. public class MyLinkedList {
  4.     //把结点包装起来
  5.     static class ListNode{
  6.         public int val;
  7.         public ListNode prev;//前驱
  8.         public ListNode next;//后继
  9.  
  10.         public ListNode(int val){
  11.             this.val = val;
  12.         }
  13.     }
  14.  
  15.     //定义指向头部和尾部的指针
  16.     public ListNode head;
  17.     public ListNode last;
  18.  
  19.     //遍历整个表
  20.     public void display(){
  21.         ListNode cur = head;
  22.         while(cur != null){
  23.             System.out.println(cur.val + " ");
  24.             cur = cur.next;
  25.         }
  26.         System.out.println();
  27.     }
  28.  
  29.     //头插法 O(1)
  30.     public void addFirst(int data){
  31.         //先创建一个结点
  32.         ListNode newNode = new ListNode(data);
  33.         //判断原来是否为空表
  34.         if(head == null){
  35.             head = newNode;
  36.             last = newNode;
  37.         }else{//原表有数据，往里面添加数据
  38.             newNode.next = head;
  39.             head.prev = newNode;
  40.             head = newNode;
  41.         }
  42.     }
  43.  
  44.     //尾插法 O(1)
  45.     public void addLast(int data){
  46.         ListNode newNode = new ListNode(data);
  47.         //判断原来是否为空表
  48.         if(head == null){
  49.             head = newNode;
  50.             last = newNode;
  51.         }else{//原表有数据，往里面添加数据
  52.             last.next = newNode;
  53.             newNode.prev = last;
  54.             last = newNode;
  55.         }
  56.     }
  57.  
  58.     //任意位置插入,第一个数据节点为0号下标
  59.     public void addIndex(int index,int data){
  60.         //先判断index是否合法
  61.         if(index < 0 || index > size()){
  62.             throw new ListIndexOutOfException("index不合法");
  63.         }
  64.         //如果index为0，调用头插法
  65.         if(index == 0){
  66.             addFirst(data);
  67.             return;
  68.         }
  69.         //如果index为size()，调用尾插法
  70.         if(index == size()){
  71.             addLast(data);
  72.             return;
  73.         }
  74.         //在其他位置进行插入
  75.         //先找到插入结点的位置
  76.         ListNode cur = findIndex(index);
  77.         //创建一个新的结点
  78.         ListNode newNode = new ListNode(data);
  79.         //进行插入
  80.         newNode.next = cur;
  81.         cur.prev.next = newNode;
  82.         newNode.next = cur;
  83.         cur.prev = newNode;
  84.  
  85.     }
  86.  
  87.     //找到插入结点的位置
  88.     private ListNode findIndex(int index){
  89.         ListNode cur = head;
  90.         while(index > 0){
  91.             cur = cur.next;
  92.             index--;
  93.         }
  94.         return cur;
  95.     }
  96.  
  97.  
  98.     //计算大小
  99.     public int size(){
  100.         int count = 0;
  101.         ListNode cur = head;
  102.         while(cur != null){
  103.             count++;
  104.             cur = cur.next;
  105.         }
  106.         return count;
  107.     }
  108.  
  109.     //查找是否包含关键字key是否在单链表当中
  110.     public boolean contains(int key){
  111.         ListNode cur = head;//作为代步滴滴
  112.         while(cur != null){
  113.             if (cur.val == key){
  114.                 return true;
  115.             }
  116.             cur = cur.next;
  117.         }
  118.         return false;
  119.     }
  120.  
  121.     //删除第一次出现关键字为key的节点
  122.     public void remove(int key){
  123.         ListNode cur = head;
  124.         while (cur != null){
  125.             //开始删除
  126.             if(cur.val == key){
  127.                 //1. 如果删除的是第一个结点
  128.                 if(head.val == key){
  129.                     head = head.next;
  130.                     //1.1 如果不是只有一个结点的时候
  131.                     //才可以将前驱结点做空
  132.                     if(head != null){
  133.                         head.prev = null;
  134.                     }
  135.                 }else{//2. 如果删除的是其他结点
  136.                     //中间结点
  137.                     cur.prev.next = cur.next;
  138.                     //cur.next.prev = cur.prev;cur指向的是尾结点，cur.next.prev 就会发生空指针异常
  139.                     //所以需要当不是尾结点时，才能执行这段代码
  140.                     if(cur.next != null){
  141.                         cur.next.prev = cur.prev;
  142.                     }else{//如果是尾巴结点
  143.                         last = last.prev;
  144.                     }
  145.                 }
  146.                 return;//如果是删除一个结点就多了个return
  147.             }
  148.             cur = cur.next;
  149.         }
  150.     }
  151.  
  152.     //删除所有值为key的节点
  153.     public void removeAllKey(int key){
  154.         ListNode cur = head;
  155.         while (cur != null){
  156.             //开始删除
  157.             if(cur.val == key){
  158.                 //1. 如果删除的是第一个结点
  159.                 if(head.val == key){
  160.                     head = head.next;
  161.                     //1.1 如果不是只有一个结点的时候
  162.                     //才可以将前驱结点做空
  163.                     if(head != null){
  164.                         head.prev = null;
  165.                     }
  166.                 }else{//2. 如果删除的是其他结点
  167.                     //中间结点
  168.                     cur.prev.next = cur.next;
  169.                     //cur.next.prev = cur.prev;cur指向的是尾结点，cur.next.prev 就会发生空指针异常
  170.                     //所以需要当不是尾结点时，才能执行这段代码
  171.                     if(cur.next != null){
  172.                         cur.next.prev = cur.prev;
  173.                     }else{//如果是尾巴结点
  174.                         last = last.prev;
  175.                     }
  176.                 }
  177.             }
  178.             cur = cur.next;
  179.         }
  180.     }
  181.  
  182.     public void clear(){
  183.         /*ListNode cur = head;
  184.         while (cur != null) {
  185.             ListNode curNext = cur.next;
  186.             cur.prev = null;
  187.             cur.next = null;
  188.             cur = curNext;
  189.         }*/
  190.         head = null;
  191.         last = null;
  192.     }
  193. }

3. MySingleList与MyLinkedList代码上的区别

最大区别MySingleListMyLinkedList
删除结点需要找到想删除结点的上一个结点不需要找到删除结点的上一个结点，只需要找到想删除的结点

4. LinkedList的使用

4.1 什么是LinkedList

LinkedList的官方文档
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

 【说明】

1. LinkedList实现了List接口

2. LinkedList的底层使用了双向链表

3. LinkedList没有实现RandomAccess（该接口是实现随机访问）接口，因此LinkedList不支持随机访问

4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

5. LinkedList比较适合任意位置插入的场景

4.2 LinkedList的使用

4.2.1 LinkedList的构造

方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
  1. public static void main(String[] args) {
  2.   // 构造一个空的LinkedList
  3.   List<Integer> list1 = new LinkedList<>();
  4.  
  5.   List<String> list2 = new java.util.ArrayList<>();
  6.   list2.add("JavaSE");
  7.   list2.add("JavaWeb");
  8.   list2.add("JavaEE");
  9.   // 使用ArrayList构造LinkedList
  10.   List<String> list3 = new LinkedList<>(list2);
  11. }

4.2.2 LinkedList的其他常用方法介绍

LinkedList的使用文档

  1. public static void main(String[] args) {
  2.   LinkedList<Integer> 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.   System.out.println(list.size());
  11.   System.out.println(list);
  12.  
  13.   // 在起始位置插入0
  14.   list.add(0, 0);  // add(index, elem): 在index位置插入元素elem
  15.   System.out.println(list);
  16.  
  17.   list.remove();     // remove(): 删除第一个元素，内部调用的是removeFirst()
  18.   list.removeFirst();   // removeFirst(): 删除第一个元素
  19.   list.removeLast();   // removeLast(): 删除最后元素
  20.   list.remove(1);  // remove(index): 删除index位置的元素
  21.   System.out.println(list);
  22.  
  23.   // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
  24.   if(!list.contains(1)){
  25.   list.add(0, 1);
  26.   list.add(1);
  27.   System.out.println(list);
  28.   System.out.println(list.indexOf(1));  // indexOf(elem): 从前往后找到第一个elem的位置
  29.   System.out.println(list.lastIndexOf(1));  // lastIndexOf(elem): 从后往前找第一个1的位置
  30.   int elem = list.get(0);   // get(index): 获取指定位置元素
  31.   list.set(0, 100);      // set(index, elem): 将index位置的元素设置为elem
  32.   System.out.println(list);
  33.  
  34.   // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
  35.   List<Integer> copy = list.subList(0, 3); 
  36.   System.out.println(list);
  37.   System.out.println(copy);
  38.   list.clear();        // 将list中元素清空
  39.   System.out.println(list.size());
  40. }
  41.

4.2.3 LinkedList的遍历

  1. public static void main(String[] args) {
  2.   LinkedList<Integer> 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.   System.out.println(list.size());
  11.   // foreach遍历
  12.   for (int e:list) {
  13.     System.out.print(e + " ");
  14.  }
  15.   System.out.println();
  16.   // 使用迭代器遍历---正向遍历
  17.   ListIterator<Integer> it = list.listIterator();
  18.   while(it.hasNext()){
  19.     System.out.print(it.next()+ " ");
  20.  }
  21.   System.out.println();
  22.   // 使用反向迭代器---反向遍历
  23.   ListIterator<Integer> rit = list.listIterator(list.size());
  24.   while (rit.hasPrevious()){
  25.     System.out.print(rit.previous() +" ");
  26.  }
  27.   System.out.println();
  28. }

5. ArrayList和LinkedList的区别

不同点ArrayListLinkedList
存储空间上物理上一定连续 逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持：O(N)
头插需要搬移元素，效率低O(N) 只需修改引用的指向，时间复杂度为O(1)
插入空间不够时需要扩容 没有容量的概念
应用场景元素高效存储+频繁访问 任意位置插入和删除频繁

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/823005
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号