devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构之链表 - 超详细的教程，手把手教你认识并运用链表_链表数据结构

作者：盐析白兔 | 2024-06-07 17:19:09

赞

踩

链表数据结构

目录

1. ArrayList的缺陷

2. 链表

2.1 链表的概念以及结构

2.2 链表的实现

 3. 链表练习题

 4. LinkedList的模拟实现

 5. LinkedList的使用

5.1 LinkedList的构造

5.2 LinkedList的其他常用方法介绍

5.3 LinkedList的遍历

6. ArrayList和LinkedList的区别

1. ArrayList的缺陷

顺序表只适合静态的查找和更新，不适合插入和删除元素，

因为在ArrayList中插入和删除元素时，由于需要将后序元素往前后者往后移动，所以时间复杂度会相当高，能达到O(N)。

为了解决这一问题，java 引入了 LinkedList(链表)。

2. 链表

2.1 链表的概念以及结构

链表是一种逻辑上连续，物理上不连续的存储结构。

链表是由一个个节点连接构成的，一个节点包含 val 域和 next 域。

逻辑上连续是因为链表有一个 next 域，这个 next 域会指向下一个节点。

每个节点都是一个对象，因此他们都会有属于自己的地址。

上图就是一个不带头单向非循环的链表。

其实，链表的结构有很多种。

1. 带头和不带头

此处的带头和不带头指的是，是否有一个虚拟的头节点，该头节点的 val 是无效值，该头节点的下一个节点才是链表的第一个节点，head 会固定指向该虚拟的头节点，不能修改 head 的指向。

2. 单向和双向

单向和双向，顾名思义，就是只能指向一个方向的和能够指向两个方向的

单向的链表只有两个域(val + next)，而双向的链表则比单向的链表多一个域 prev

单向的链表只能向后(next)走，而双向的链表既能向后(next)走，也能向前(prev)走

3. 循环和非循环

顾名思义，就是循环的链表和不是循环的链表咯

虽然链表的种类有这么多，但是我们只用重点掌握两种：单向不带头非循环和双向不带头非循环。

单向不带头非循环：结构简单，面试题考的多。

双向不带头非循环：LinkedList 的底层实现结构就是双向不带头非循环链表。

2.2 链表的实现

此处链表的实现，实现的是单向不带头非循环链表。

要实现一个链表，我们就得先创建一个 MySingleList 类，我们要实现的就是 MySingleList 类。

由刚刚学过的知识可以知道，链表是由一个个节点组成的，节点是链表的一部分

所以我们还需要定义一个静态内部类 ListNode 作为节点。

一个节点 = val + next ,所以 ListNode 有两个成员变量，

我们顺便再把 ListNode 的构造方法写出来。

而链表本身自带一个 head 节点指向头节点，所以我们还需要定义一个成员变量 head

 因为没有一个完整的链表，所以我们可以写一个方法，手动创建一个链表，这样方便我们测试这个链表方法写对没。

要实现链表，则需要实现以下方法

  1.     //头插法
  2.     public void addFirst(int data) {
  3.     }
  4.  
  5.     //尾插法
  6.     public void addLast(int data) {
  7.     }
  8.  
  9.     //任意位置插入,第一个数据节点为0号下标
  10.     public void addIndex(int index, int data) {
  11.     }
  12.  
  13.     //查找是否包含关键字key是否在单链表当中
  14.     public boolean contains(int key) {
  15.         return false;
  16.     }
  17.  
  18.     //删除第一次出现关键字为key的节点
  19.     public void remove(int key) {
  20.     }
  21.  
  22.     //删除所有值为key的节点
  23.     public void removeAllKey(int key) {
  24.     }
  25.  
  26.     //得到单链表的长度
  27.     public int size() {
  28.         return -1;
  29.     }
  30.  
  31.     //清空链表
  32.     public void clear() {
  33.     }
  34.  
  35.     //打印链表
  36.     public void display() {
  37.     }

我们可以先挑选简单的实现，可以选择先实现 size，display，contains 和 clear

那我们就先来实现 size 方法，求链表的长度。

思路就是遍历链表，遇到一个节点，count就++。

那我们就可以定义一个 cur ，cur 指向 head，然后遍历即可

不能直接用 head 来遍历链表，因为如果 head 走了，链表就不知道从哪里开始了。

然后我们再来实现 display ，打印链表

 同理，我们要把链表的每一个数字都打印出来，就需要遍历链表，

遍历到一个节点，就打印一个节点。

再来实现 contains 方法，查找 key 是否在链表中存在，

这个也一样，遍历链表，找到了就返回 true ， 遍历完链表了还找不到，那就返回 false

再来实现 clear，这不简单，只要将头节点置 null 了，链表也就清空了 

再来实现 addFirst ，头插法

头插法的意思就是，新增一个节点，将该节点插入到链表的第一个，也就是头节点的位置。

分两种情况，第一种，链表为空，第二种，链表不为空。

如果链表为空，说明链表里面没有节点，那新增的这个 node 节点就是链表的第一个节点，也就是头节点。

如果链表不为空，那我们需要牢记这一点：插入节点的时候，先绑定后面的数据，再来插入节点

 如上图解

再来实现 addLast，尾插法，与头插法类似

尾插法，就是把新增的节点插入到链表的尾巴，也就是链表最后一个节点的位置 。

同理，尾插法也分为两种情况，

第一种，链表为空，说明链表里面一个节点都没有，所以新增的节点，就相当于链表的第一个节点，也就是头节点。

第二种，链表不为空，新增的节点要插入到链表的尾巴，则需要先找到链表的尾巴节点，再来插入。

由上图，我们不难发现，链表尾巴节点和其他节点的区别：那就是尾巴节点的 next 域 为 null

所以，我们就能借助这点，找到链表的尾巴节点。

 

再来写 addIndex，指定位置插入 

因为 addIndex 方法含有参数 index，所以根据 index ，分为四种情况

第一种，非法情况，如果下标小于0或者大于链表的长度，则不合法，不合法就不用插了。

第二种，下标刚好是0，说明是头插法，直接调用我们刚刚写好的 addFirst 即可。

第三种，下标刚好是链表长度，说明是插在最后一个位置，尾插法，直接调用 addLast 即可。

第四种，index 不是以上三种情况，说明 index 位置是在链表中间位置。

则需要我们先找到下标位置的前一个节点，然后绑定数据，再来插入

 

然后我们再来实现 remove 方法，删除第一个关键字为 key 的节点

那很简单，首先要找到关键字为 key 的节点，再来删除。

如果链表为 null ，说明没有节点给你删除

如果 head.val == key,说明删除头节点

因为要删除 key 的节点，所以得先找到 关键字为 key 的节点的前一个节点，才能进行删除

所以我们可以单独写一个方法，来找，关键字为 key 的节点的前一个节点。

遍历链表，找 key 的节点 的前一个，找到了就返回该节点，找不到就返回 null 

找到了 prev(key节点的前一个节点)之后，就直接删除 prev.next 即可

 再来实现 removeAllKey 方法，删除所有值为 key 的节点

  1. public class MySingleList {
  2.  
  3.     static class ListNode {
  4.         //一个节点包含 val 和 next
  5.         public int val;//节点的值域
  6.         public ListNode next;//下一个节点的地址
  7.  
  8.  
  9.         //提供构造方法
  10.         public ListNode(int val) {
  11.             this.val = val;
  12.         }
  13.     }
  14.  
  15.     //对于链表本身来说，必须得有一个头结点
  16.     public ListNode head;//指向当前链表的头节点
  17.  
  18.     public void createList() {
  19.         //创建链表，让每个节点连起来即可
  20.         ListNode n1 = new ListNode(12);
  21.         ListNode n2 = new ListNode(23);
  22.         ListNode n3 = new ListNode(34);
  23.         ListNode n4 = new ListNode(45);
  24.         ListNode n5 = new ListNode(56);
  25.  
  26.         //通过 next 建立节点之间的联系
  27.         n1.next = n2;
  28.         n2.next = n3;
  29.         n3.next = n4;
  30.         n4.next = n5;
  31.  
  32.         this.head = n1;
  33.     }
  34.  
  35.     //得到单链表的长度
  36.     public int size() {
  37.         int count = 0;
  38.  
  39.         //用 cur 来遍历链表
  40.         ListNode cur = head;
  41.  
  42.         //cur == null说明链表遍历完了
  43.         while (cur != null) {
  44.             count++;
  45.             cur = cur.next;//让 cur 指向下一个节点
  46.         }
  47.  
  48.         return count;
  49.     }
  50.  
  51.     //打印链表
  52.     public void display() {
  53.         ListNode cur = head;
  54.  
  55.         //遍历链表
  56.         while (cur != null) {
  57.             System.out.print(cur.val + " ");
  58.             cur = cur.next;
  59.         }
  60.  
  61.         System.out.println();
  62.     }
  63.  
  64.     //查找是否包含关键字key是否在单链表当中
  65.     public boolean contains(int key) {
  66.         ListNode cur = head;
  67.  
  68.         while (cur != null) {
  69.             //遍历链表，找到了就返回 true
  70.             if (cur.val == key) {
  71.                 return true;
  72.             }
  73.             cur = cur.next;
  74.         }
  75.         //找不到就返回 false
  76.         return false;
  77.     }
  78.  
  79.     //清空链表
  80.     public void clear() {
  81.         this.head = null;//头节点为null，就找不到其他结点了
  82.     }
  83.  
  84.  
  85.     //头插法
  86.     public void addFirst(int data) {
  87.         ListNode node = new ListNode(data);
  88.  
  89.         if (head == null) {
  90.             head = node;
  91.             return;
  92.         }
  93.         //绑定后面的数据
  94.         node.next = head;
  95.         //更新头
  96.         head = node;
  97.     }
  98.  
  99.     //尾插法
  100.     public void addLast(int data) {
  101.  
  102.         ListNode node = new ListNode(data);
  103.         //如果 head 为 null ，说明链表没有结点
  104.         if (head == null) {
  105.             head = node;
  106.             return;
  107.         }
  108.  
  109.         ListNode cur = head;
  110.         //找到链表的尾巴节点
  111.         while (cur.next != null) {
  112.             cur = cur.next;
  113.         }
  114.         //到了这里说明 cur 指向了尾巴节点
  115.         //插入
  116.         cur.next = node;
  117.  
  118.     }
  119.  
  120.     //任意位置插入,第一个数据节点为0号下标
  121.     public void addIndex(int index, int data) {
  122.         // index 不合法，则不能插入
  123.         if (index < 0 || index > size()) {
  124.             return;
  125.         }
  126.         if (index == 0) {
  127.             //头插法
  128.             addFirst(data);
  129.             return;
  130.         }
  131.         if (index == size()) {
  132.             //尾插法
  133.             addLast(data);
  134.             return;
  135.         }
  136.         //中间位置
  137.         ListNode cur = head;
  138.         //走 index - 1 步,找到要删除结点位置的前一个结点
  139.         int step = index - 1;
  140.         while (step != 0) {
  141.             cur = cur.next;
  142.             step--;
  143.         }
  144.         //先绑定后面的数据
  145.         ListNode node = new ListNode(data);
  146.         node.next = cur.next;
  147.         //再来插入
  148.         cur.next = node;
  149.     }
  150.  
  151.  
  152.     //删除第一次出现关键字为key的节点
  153.     public void remove(int key) {
  154.         //空表删不了
  155.         if (head == null) {
  156.             return;
  157.         }
  158.         //如果是头节点
  159.         if (head.val == key) {
  160.             head = head.next;
  161.             return;
  162.         }
  163.         //找到 key 节点的前一个节点
  164.         ListNode prev = findKeySubOne(key);
  165.         if (prev == null) {
  166.             //说明不存在 key 节点的前一个节点
  167.             return;
  168.         } else {
  169.             ListNode target = prev.next;// target 为要删除的节点
  170.             //删除
  171.             prev.next = target.next;
  172.         }
  173.  
  174.     }
  175.  
  176.     private ListNode findKeySubOne(int key) {
  177.         //空表
  178.         if (head == null) {
  179.             return null;
  180.         }
  181.         ListNode cur = head;
  182.         //找到要删除的前一个结点
  183.         //必须得判断 cur.next 是否为空，不然有可能会空指针异常
  184.         //如果 cur.next == null,那么 cur 已经是尾巴结点，就没有继续判断的必要了
  185.         while (cur.next != null) {
  186.             if (cur.next.val == key) {
  187.                 return cur;
  188.             }
  189.             cur = cur.next;
  190.         }
  191.         return null;
  192.     }
  193.  
  194.     //删除所有值为key的节点
  195.     public void removeAllKey(int key) {
  196.         //空表
  197.         if (head == null) {
  198.             return;
  199.         }
  200.  
  201.         ListNode prev = head;// prev 为 del 的前一个
  202.         ListNode del = head.next;// del 表示要删除的元素
  203.         // del 不为空，说明还有，有可能要删除的节点
  204.         while (del != null) {
  205.             if (del.val == key) {
  206.                 //删除
  207.                 prev.next = del.next;
  208.                 //del往后走
  209.                 del = del.next;
  210.             } else {
  211.                 //两个都往后走
  212.                 prev = del;
  213.                 del = del.next;
  214.             }
  215.         }
  216.         //最后再来判断头节点
  217.         if (head.val == key) {
  218.             head = head.next;
  219.         }
  220.     }
  221.  
  222. }

 3. 链表练习题

203. 移除链表元素

 

刚刚写过删除所有值为 key 的节点，直接复制代码到 LeetCode 上，改下方法名字即可。

  1. class Solution {
  2.     public ListNode removeElements(ListNode head, int val) {
  3.         if (head == null) {
  4.             return null;
  5.         }
  6.         ListNode prev = head;
  7.         ListNode del = head.next;
  8.         while (del != null) {
  9.             if (del.val == val) {
  10.                 prev.next = del.next;
  11.                 del = del.next;
  12.             } else {
  13.                 prev = del;
  14.                 del = del.next;
  15.             }
  16.         }
  17.         if (head.val == val) {
  18.             head = head.next;
  19.         }
  20.         return head;
  21.     }
  22. }

206. 反转链表

这道题，思路就是头插法，从第二个节点开始遍历链表，对链表的每个元素进行头插法即可。

  1. class Solution {
  2.     public ListNode reverseList(ListNode head) {
  3.         if (head == null) {
  4.             return null;
  5.         }
  6.         ListNode cur = head.next;//从第二个节点开始反转
  7.         ListNode prev = head;// prev 相当于新头
  8.         head.next = null;//置空，防止循环
  9.         while (cur != null) {
  10.             ListNode curNext = cur.next;
  11.             //头插法
  12.             cur.next = prev;//头插
  13.             prev = cur;//更新
  14.  
  15.             cur = curNext;//cur继续往后走
  16.         }
  17.         return prev;
  18.     }
  19. }

  

876. 链表的中间结点

思路：快慢指针，相同时间，速度两倍，路程两倍

  1. class Solution {
  2.     //找中间结点
  3.     public ListNode middleNode(ListNode head) {
  4.         if (head == null) {
  5.             return null;
  6.         }
  7.         ListNode fast = head;
  8.         ListNode slow = head;
  9.         //遍历链表，防止空指针异常
  10.         while (fast != null && fast.next != null) {
  11.             fast = fast.next.next;//一次走两步
  12.             slow = slow.next;//一次走一步
  13.         }
  14.         return slow;
  15.     }
  16. }

链表中倒数第k个结点

 思路：还是利用快慢指针，先让 fast 走 k-1步，再让 fast 和 slow 一起走，等 fast 走到尾巴节点， slow 就是倒数第 k 个节点

  1. public class Solution {
  2.     public ListNode FindKthToTail(ListNode head, int k) {
  3.         // k 不合法或者链表为空
  4.         if (head == null || k <= 0) {
  5.             return null;
  6.         }
  7.         ListNode fast = head;
  8.         ListNode slow = head;
  9.         while (k - 1 != 0) {
  10.             fast = fast.next;
  11.             if (fast == null) {
  12.                 //说明k比链表长度还大
  13.                 return null;
  14.             }
  15.             k--;
  16.         }
  17.         //你先走，然后我们同时同速走，距离不变，就是k-1步，差k个节点
  18.         while (fast.next != null) {
  19.             fast = fast.next;
  20.             slow = slow.next;
  21.         }
  22.         return slow;
  23.     }
  24. }

​​​​​​21. 合并两个有序链表

思路：与合并2个有序数组类似，定义一个dummy虚拟头节点，如果链表1的节点比链表2的节点小，那就链表1的节点加进来，如果不是，那就链表2的节点加进来，然后对应的链表往后走，遍历完之后，看看哪个链表不为空，不为空的链表就连接在后面，最后返回 dummy.next 即可。

  1. class Solution {
  2.     public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
  3.         if (list1 == null && list2 == null) {
  4.             return null;
  5.         }
  6.         if (list1 == null) {
  7.             return list2;
  8.         }
  9.         if (list2 == null) {
  10.             return list1;
  11.         }
  12.         ListNode dummy = new ListNode(-1);
  13.         ListNode cur = dummy;
  14.         while (list1 != null && list2 != null) {
  15.             if (list1.val < list2.val) {
  16.                 cur.next = list1;
  17.                 list1 = list1.next;
  18.             } else {
  19.                 cur.next = list2;
  20.                 list2 = list2.next;
  21.             }
  22.             cur = cur.next;
  23.         }
  24.         if (list1 != null) {
  25.             cur.next = list1;
  26.         }
  27.         if (list2 != null) {
  28.             cur.next = list2;
  29.         }
  30.  
  31.         return dummy.next;
  32.     }
  33. }

CM11 链表分割

思路：与合并有序链表类似，但又不完全类似，定义bs，be，as，ae，两个部分

小于x放到 b 中，大于的放到 a 中，最后让 be 和 as 连接即可

  1. public class Partition {
  2.     public ListNode partition(ListNode pHead, int x) {
  3.         //定义 bs,be,as,ae
  4.         // 小于 x 放到 b ，大于 x 放到 a 中
  5.         //最后连接 be 和 as
  6.         ListNode bs = null;
  7.         ListNode be = null;
  8.         ListNode as = null;
  9.         ListNode ae = null;
  10.  
  11.         ListNode cur = pHead;
  12.         //遍历链表
  13.         while (cur != null) {
  14.             //说明是第一次放元素
  15.             if (cur.val < x) {
  16.                 if (bs == null) {
  17.                     bs = cur;
  18.                     be = cur;
  19.                 } else {
  20.                     be.next = cur;
  21.                     be = cur;
  22.                 }
  23.  
  24.             } else {
  25.                 //第一次
  26.                 if (as == null) {
  27.                     as = cur;
  28.                     ae = cur;
  29.                 } else {
  30.                     ae.next = cur;
  31.                     ae = cur;
  32.                 }
  33.             }
  34.             cur = cur.next;
  35.         }
  36.         //如果第一段为空
  37.         if (bs == null) {
  38.             return as;
  39.         }
  40.         //如果a段存在，ae.next需要置空，防止形成循环
  41.         if (as != null) {
  42.             ae.next = null;
  43.         }
  44.         //连接a段和b段
  45.         be.next = as;
  46.         return bs;
  47.     }
  48. }

OR36 链表的回文结构

思路：1. 找到链表的中间节点 。 2. 反转中间节点之后的节点。 3. 比较

  1. public class PalindromeList {
  2.     public boolean chkPalindrome(ListNode head) {
  3.         if (head == null) {
  4.             return true;
  5.         }
  6.         ListNode fast = head;
  7.         ListNode slow = head;
  8.         //1. 找到中间节点
  9.         while (fast != null && fast.next != null) {
  10.             fast = fast.next.next;
  11.             slow = slow.next;
  12.         }
  13.         //2. 反转中间节点之后的节点
  14.         ListNode cur = slow.next;
  15.         while (cur != null) {
  16.             ListNode curNext = cur.next;//记录cur的下一个节点
  17.  
  18.             cur.next = slow;//反转
  19.             slow = cur;//更新头
  20.  
  21.             cur = curNext;//cur往后走
  22.         }
  23.         //3. 比较
  24.         while (head != slow) {
  25.             //值不相同
  26.             if (head.val != slow.val) {
  27.                 return false;
  28.             }
  29.             节点个数为偶数个时，相遇的前奏就是这个
  30.             if (head.next == slow) {
  31.                 return true;
  32.             }
  33.             head = head.next;
  34.             slow = slow.next;
  35.         }
  36.         return true;
  37.     }
  38. }

160. 相交链表

思路：

1.相交主要是Y字型

2.两个链表的长度不一样 主要体现在相交之前

3.可以让最长的链表先走它们的差值步，然后两个链表再一起走

  1. public class Solution {
  2.     public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
  3.         if (headA == null && headB == null) {
  4.             return null;
  5.         }
  6.         //1.分别求出两个链表的长度，然后做差
  7.         ListNode pL = headA;//假设A是较长的
  8.         ListNode pS = headB;
  9.         int lenA = 0;
  10.         int lenB = 0;
  11.         while (pL != null) {
  12.             lenA++;
  13.             pL = pL.next;
  14.         }
  15.         while (pS != null) {
  16.             lenB++;
  17.             pS = pS.next;
  18.         }
  19.         int len = lenA - lenB;//记录差值
  20.         pL = headA;//重新回到头结点
  21.         pS = headB;
  22.         //进行修正
  23.         if (len < 0) {
  24.             pL = headB;
  25.             pS = headA;
  26.             len = lenB - lenA;
  27.         }
  28.         //2.让较长的链表先走差值步
  29.         while (len != 0) {
  30.             pL = pL.next;
  31.             len--;
  32.         }
  33.         //3.然后两个链表再一起走
  34.         while (pL != null && pS != null) {
  35.             if (pL == pS) {
  36.                 return pL;
  37.             }
  38.             pL = pL.next;
  39.             pS = pS.next;
  40.         }
  41.         return null;
  42.     }
  43. }

141. 环形链表

思路：利用快慢指针，fast 一次走2步，slow 一次走一步，如果有环，那么能追上，没环就肯定追不上

  1. public class Solution {
  2.     //是否有环
  3.     public boolean hasCycle(ListNode head) {
  4.         if (head == null) {
  5.             return false;
  6.         }
  7.         ListNode fast = head;
  8.         ListNode slow = head;
  9.         while (fast != null && fast.next != null) {
  10.             fast = fast.next.next;//一次走两步
  11.             slow = slow.next;//一次走一步
  12.             //相当于追及问题，slow在追fast，有环就能追上，没环就追不上
  13.             if (fast == slow) {
  14.                 return true;
  15.             }
  16.         }
  17.         return false;
  18.     }
  19. }

142. 环形链表 II

思路：快慢指针，当 fast 与 slow 相遇时，让 fast 从 head 开始，和 slow 同速一起走，当 slow

 和 fast 再次相遇时，该相遇点就是环的入口点

  1. public class Solution {
  2.     //返回环的入口点
  3.     public ListNode detectCycle(ListNode head) {
  4.         if (head == null) {
  5.             return null;
  6.         }
  7.         ListNode fast = head;
  8.         ListNode slow = head;
  9.         while (fast != null && fast.next != null) {
  10.             fast = fast.next.next;
  11.             slow = slow.next;
  12.             if (fast == slow) {
  13.                 //相遇后，
  14.                 //相遇点到入口点的距离与起始点到入口点的距离相等
  15.                 fast = head;
  16.                 while (fast != null && slow != null) {
  17.                     if (fast == slow) {
  18.                         return fast;//如果fast与slow再次相遇，则该点为入口点
  19.                     }
  20.                     fast = fast.next;
  21.                     slow = slow.next;
  22.  
  23.                 }
  24.             }
  25.         }
  26.         return null;
  27.     }
  28. }

 4. LinkedList的模拟实现

和单链表同理，只是双向无头非循环链表多了一个 prev 域

与单链表相同，双向链表也由一个个节点组成，所以同理，我们要定义一个静态内部类，相比于单链表，双链表还多了一个尾巴节点，尾巴节点 last 会指向双链表的最后一个节点

双向链表与单链表相同，也要实现以下方法

  1.     //头插法
  2.     public void addFirst(int data) {
  3.     }
  4.  
  5.     //尾插法
  6.     public void addLast(int data) {
  7.     }
  8.  
  9.     //任意位置插入,第一个数据节点为0号下标
  10.     public void addIndex(int index, int data) {
  11.     }
  12.  
  13.     //查找是否包含关键字key是否在链表当中
  14.     public boolean contains(int key) {
  15.     }
  16.  
  17.     //删除第一次出现关键字为key的节点
  18.     public void remove(int key) {
  19.     }
  20.  
  21.     //删除所有值为key的节点
  22.     public void removeAllKey(int key) {
  23.     }
  24.  
  25.     //得到链表的长度
  26.     public int size() {
  27.     }
  28.  
  29.     public void display() {
  30.     }
  31.  
  32.     public void clear() {
  33.     }

同样的，我们先选择实现 size，display，contains 方法

这些方法的实现与单链表没什么区别，直接按照你写单链表的方式来写上述三个方法即可。

再来实现 clear 方法，需要注意，每一个节点的 prev 和 next 都要手动置空，last 和 head 也要置空

再来实现头插法，与单链表类似，分两种情况

第一种，链表为空，说明新增的节点既是头节点又是尾巴节点

第二种，链表不为空，则先需要绑定后面的数据，再来插入

再来实现尾插法，同样与单链表类似，分两种情况

第一种，链表为空，相当于头插

第二种，链表不为空，先绑定数据，再来插入

再来实现 addIndex，与单链表类似，分四种情况

第一种，index 不合法，不能插入

第二种，index = 0，相当于头插法

第三种，index = size() ,相当于尾插法

第四种，不是以上三种情况，首先先找到 index 下标的节点，先绑定数据，再进行插入

第四种情况与单链表类似，先让 cur 走 index 步，然后绑定数据，进行插入。

然后我们再来实现 remove 方法，

思路：遍历链表，如果要删除的是头节点，就需要考虑该链表是否只有一个节点，

如果要删除的不是头节点，那就得判断要删除的节点是尾巴节点，还是中间节点

再来实现 removeAllKey 方法，思路与 remove 方法类似，只不过 remove 方法是删一次就走人了，而 removeAllKey 方法，是要删除多次

  1. // 无头双向链表实现
  2. public class MyLinkedList {
  3.  
  4.     static class ListNode {
  5.         public int val;//节点的值域
  6.         public ListNode prev;//指向上一个节点
  7.         public ListNode next;//指向下一个节点
  8.  
  9.         //提供构造方法
  10.         public ListNode(int val) {
  11.             this.val = val;
  12.         }
  13.     }
  14.  
  15.     public ListNode head;//头节点
  16.     public ListNode last;//尾巴节点
  17.  
  18.  
  19.     //得到链表的长度
  20.     public int size() {
  21.         int count = 0;
  22.         ListNode cur = head;
  23.         while (cur != null) {
  24.             count++;
  25.             cur = cur.next;
  26.         }
  27.         return count;
  28.     }
  29.  
  30.     public void display() {
  31.         ListNode cur = head;
  32.         while (cur != null) {
  33.             System.out.print(cur.val + " ");
  34.             cur = cur.next;
  35.         }
  36.     }
  37.  
  38.     //查找是否包含关键字key是否在链表当中
  39.     public boolean contains(int key) {
  40.         ListNode cur = head;
  41.         while (cur != null) {
  42.             if (cur.val == key) {
  43.                 return true;
  44.             }
  45.             cur = cur.next;
  46.         }
  47.         return false;
  48.     }
  49.  
  50.     public void clear() {
  51.         ListNode cur = head;
  52.         //要将链表的每一个元素手动置空
  53.         while (cur != null) {
  54.             ListNode curNext = cur.next;
  55.             cur.prev = null;
  56.             cur.next = null;
  57.             cur = curNext;
  58.         }
  59.         this.head = null;
  60.         this.last = null;
  61.     }
  62.  
  63.  
  64.     //头插法
  65.     public void addFirst(int data) {
  66.         ListNode node = new ListNode(data);
  67.         if (head == null) {
  68.             head = node;
  69.             last = node;
  70.         } else {
  71.             //先绑定数据
  72.             node.next = head;
  73.             head.prev = node;
  74.             //再来插入
  75.             head = node;///更新头
  76.         }
  77.     }
  78.  
  79.     //尾插法
  80.     public void addLast(int data) {
  81.         if (head == null) {
  82.             addFirst(data);
  83.         } else {
  84.             ListNode node = new ListNode(data);
  85.             //先绑定数据
  86.             node.prev = last;
  87.             last.next = node;
  88.             //再进行插入
  89.             last = node;
  90.         }
  91.     }
  92.  
  93.     //任意位置插入,第一个数据节点为0号下标
  94.     public void addIndex(int index, int data) {
  95.         if (index < 0 || index > size()) {
  96.             return;
  97.         }
  98.         if (index == 0) {
  99.             addFirst(data);
  100.             return;
  101.         }
  102.         if (index == size()) {
  103.             addLast(data);
  104.             return;
  105.         }
  106.         ListNode cur = head;
  107.         while (index != 0) {
  108.             cur = cur.next;
  109.             index--;
  110.         }
  111.         ListNode node = new ListNode(data);
  112.  
  113.         ListNode prev = cur.prev;
  114.         //先绑定数据
  115.         node.prev = prev;
  116.         node.next = cur;
  117.         //再来插入
  118.         prev.next = node;
  119.         cur.prev = node;
  120.     }
  121.  
  122.  
  123.     //删除第一次出现关键字为key的节点
  124.     public void remove(int key) {
  125.         ListNode cur = head;
  126.         while (cur != null) {
  127.             if (cur.val == key) {
  128.                 //删除头节点
  129.                 if (cur == head) {
  130.                     head = head.next;
  131.                     //考虑只有一个节点的情况
  132.                     if (head == null) {
  133.                         last = null;
  134.                     } else {
  135.                         head.prev = null;
  136.                     }
  137.                 } else {
  138.                     //是否是尾巴节点
  139.                     if (cur.next == null) {
  140.                         //删除尾巴节点
  141.                         last = last.prev;
  142.                         last.next = null;
  143.                     } else {
  144.                         //删除中间节点
  145.                         cur.prev.next = cur.next;
  146.                         cur.next.prev = cur.prev;
  147.                     }
  148.  
  149.                 }
  150.                 //删完之后就走人
  151.                 return;
  152.             }
  153.             cur = cur.next;
  154.         }
  155.     }
  156.  
  157.     //删除所有值为key的节点
  158.     public void removeAllKey(int key) {
  159.         ListNode cur = head;
  160.         while (cur != null) {
  161.             if (cur.val == key) {
  162.                 //删除头节点
  163.                 if (cur == head) {
  164.                     head = head.next;
  165.                     //考虑只有一个节点的情况
  166.                     if (head == null) {
  167.                         last = null;
  168.                     } else {
  169.                         head.prev = null;
  170.                     }
  171.                 } else {
  172.                     //是否是尾巴节点
  173.                     if (cur.next == null) {
  174.                         //删除尾巴节点
  175.                         last = last.prev;
  176.                         last.next = null;
  177.                     } else {
  178.                         //删除中间节点
  179.                         cur.prev.next = cur.next;
  180.                         cur.next.prev = cur.prev;
  181.                     }
  182.                 }
  183.                 cur = cur.next;//继续删
  184.             } else {
  185.                 cur = cur.next;
  186.             }
  187.         }
  188.     }
  189.  
  190. }

 5. LinkedList的使用

LinkedList 的底层结构是双向链表，由于任意位置插入和删除时不需要挪动元素，所以效率较高。
在集合框架中， LinkedList 也实现了 List 接口。
1. LinkedList 实现了 List 接口
2. LinkedList 的底层使用了双向链表
3. LinkedList 没有实现 RandomAccess 接口，因此 LinkedList 不支持随机访问
4. LinkedList 的任意位置插入和删除元素时效率比较高，时间复杂度为 O(1)
5. LinkedList 比较适合任意位置插入的场景

5.1 LinkedList的构造

5.2 LinkedList的其他常用方法介绍

刷题的时候直接用就行

5.3 LinkedList的遍历

可以使用 foreach 循环遍历，或者使用迭代器遍历

  1.     public static void main(String[] args) {
  2.         List<Integer> list = new LinkedList<>();
  3.         list.add(1);
  4.         // 1.使用 foreach 遍历
  5.         for (int x : list) {
  6.             System.out.print(x + " ");
  7.         }
  8.         // 2.使用迭代器遍历
  9.         Iterator<Integer> iterator = list.listIterator();
  10.         while (iterator.hasNext()) {
  11.             System.out.print(iterator.next() + " ");
  12.         }
  13.     }

6. ArrayList和LinkedList的区别

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

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

  

闽ICP备14008679号