今天我们来聊聊链表。
首先我们要搞清楚什么是链表。
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链表的入口节点称为链表的头结点也就是head。
如图所示：
链表的分类：
单链表：即上述所示
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。双链表既可以向前查询也可以向后查询。
循环链表，顾名思义，就是链表首尾相连。循环链表可以用来解决约瑟夫环问题。
链表的存储方式：
我们知道数组在内存中是连续分布的，但链表在内存中可不是连续的分布的。
链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
链表的操作：
添加链表：如果要在链表中添加元素，无需将整个链表元素进行移动，只需要将所要插入位置的前一个节点的指针域指向新节点，再将新节点的指针域指向原纤维质的后一个节点即可。
删除节点：删除节点只需将被删除节点的前一个节点的指针域指向被删除节点的后一个节点即可。
由此可见：对于链表来说，增删操作较为便利，但查询比较麻烦；而对于数组来说，查询更加容易而增删操作较为复杂。
上述只是对于链表的简单描述，想要更加深刻细致的了解链表的话，可以搜索代码随想录进行深入学习。
简单描述完关于链表的内容，我们来看一些leetcode上关于链表的题目
今天我做了三道，分别是203。移除链表元素，707.设计链表，206.反转链表
话不多说，上题！
203 移除链表元素
题目描述：
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50
解题思路及心得：
遇到此题，我们首先要理解什么是链表 链表就是一种通过指针串联在一起，每一个节点由两部分组成，一个是数据域一个是指针域（即存放下一个节点的指针），最后一个节点的指针域指向null，链表的入口节点称为链表的头节点也就是head。 当需要我们移除元素时，只需要将被移除元素的上一个元素的指针指向被移除元素的下一个元素，即可移除元素。那么我们在做这道题时，就可以使用这样的思路。 那么随之而来的是一个新的问题，如果要移除的元素即头节点呢，头节点并没有前一个节点，此时我们可以使用两种方法： 1.将head直接移向原先头结点的下一个节点，即head = head.next 2.设置一个虚拟头节点放在原先头节点的前方，即可使用普通的移除元素的方法来移除原先的头节点 那么基于这两种方法，我们在解题时也可以用两种方式： 1.原链表移除：
public ListNode removeElements(ListNode head, int val) {
while (head != null && head.val == val) {
head = head.next;
}
// 已经为null，提前退出
if (head == null) {
return head;
}
// 已确定当前head.val != val
ListNode pre = head;
ListNode cur = head.next;
while (cur != null) {
if (cur.val == val) {
pre.next = cur.next;
} else {
pre = cur;
}
cur = cur.next;
}
return head;
}
注意：判断不为空的目的是防止爆空指针异常
2.使用虚拟头节点的方式：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeElements(ListNode head, int val) {
if(head == null){
return head;
}
//设置虚拟头节点
ListNode dummy = new ListNode(-1,head);
ListNode pre = dummy;
ListNode cru = head;
while(cru != null){
if(cru.val == val){
pre.next = cru.next;
} else {
pre = cru;
}
cru = cru.next;
}
return dummy.next;
}
}
707 设计链表
题目描述：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
示例：
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3
提示：
0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。
做题思路及心得：
这道题目是练习操作链表非常好的题目，依旧可以用两个方法来解题，即直接使用原来的链表进行操作或设置一个虚拟头节点来操作。 那么下面我们采用虚拟头节点的方式来解题：
class MyLinkedList {
//size存储链表元素的个数
int size;
//虚拟头节点
ListNode head;
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是头节点
public int get(int index) {
//如果index非法，返回-1
if(index <0 || index >= size){
return -1;
}
ListNode currentNode = head;
//包含一个虚拟头节点，所以查找第index+1个节点
for(int i = 0;i <= index;i++){
currentNode = currentNode.next;
}
return currentNode.val;
}
//在链表最前面插入一个节点，等价于在第0个元素前添加
public void addAtHead(int val) {
addAtIndex(0,val);
}
//在链表的最后插入节点等价于在(末尾+1)个元素前插入
public void addAtTail(int val) {
addAtIndex(size,val);
}
//在第index个节点之前插入一个新节点，例如index为0，那么插入的节点为链表的新头节点
//如果index等于链表的长度，则说明新插入的节点为链表的尾节点
//如果index大于链表的长度，则返回空
public void addAtIndex(int index, int val) {
if(index > size){
return;
}
if(index < 0){
index = 0;
}
size++;
//找到要插入节点的前驱
ListNode pre = head;
for(int i = 0;i < index;i++){
pre = pre.next;
}
//定义新节点
ListNode toAdd = new ListNode(val);
toAdd.next = pre.next;
pre.next = toAdd;
//这里要注意赋值的顺序，如果先写pre.next = toAdd,那么原先pre.next指针就丢失了，我们无法让新节点与下一个节点连接起来，所以一定要注意赋值的顺序，避免出错
}
//删除第index个节点
public void deleteAtIndex(int index) {
if(index < 0 || index >= size){
return;
}
size--;
if(index == 0){
head = head.next;
return;
}
ListNode pred = head;
for(int i = 0;i < index;i++){
pred = pred.next;
}
pred.next = pred.next.next;
}
}
在解题时，因为在链表开头插入节点和在链表末尾插入节点都可以看作在第index个节点前插入新节点的特殊情况，所以我们可以直接调用addAtIndex()方法来解决，避免重复代码。
206 反转链表
题目描述：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
做题思路及心得：
反转链表，顾名思义即将原先链表的顺序颠倒过来，原来的头节点变成尾节点，原来的尾节点变成头节点，如果再定义一个新的链表，是对内存空间的浪费，所以我们只需要改变链表next指针的指向，就可以将链表反转。 我们知道尾节点指向null，那么当反转后，原先的头节点变成了尾节点，也将指向null；所以我们首先定义一个cur指针指向原来的头节点，在定义一个头节点之前的节点pre初始化为null。 那么接下来就要开始反转了，防止断链，我们需要定义一个temp指针来保存cur.next节点，因为接下来我们要改变cru的指向，将pre赋给cru.next，再将cru赋值给pre，cru变成cru.next,如果我们没有事先保存cru.next，则会造成cru.next丢失，也就造成了断链。 接下来我们不断地循环反转，继续移动pre，cru指针，直到cru指针指向null时，即走到了原先链表的尾节点指向的null，此时便完成了整个链表的反转，pre也变成了新链表的头节点。 上述就是做题的逻辑，那么接下来我们可以使用两种方法解题 第一种是必须掌握的双指针法： 代码如下：
class Solution {
public ListNode reverseList(ListNode head) {
ListNode pre = null;
ListNode cru = head;
ListNode temp = null;
while(cru != null){
temp = cru.next;
cru.next = pre;
pre = cru;
cru = temp;
}
return pre;
}
}
第二种方法是比较难理解的递归法，但本质逻辑与双指针法是完全相同的，只要我们理解了双指针发，按照相同的逻辑就可以很容易的理解递归法的思路 代码如下：
class Solution {
public ListNode reverseList(ListNode head) {
return reverse(null,head);
}
private ListNode reverse(ListNode pre, ListNode cru){
if(cru == null){
return pre;
}
ListNode temp = cru.next;
cru.next = pre;
return reverse(cru,temp);
}
}
以上就是今天的分享，希望可以对大家有所帮助。
669
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
