本文详细介绍了链表的基本概念，包括单链表的构造与应用，力扣刷题中常见的链表操作，如移除元素、反转、节点交换、删除倒数第N个节点、链表相交和环形链表的检测。通过实例演示和代码实现，帮助理解链表在实际问题中的运用和解决策略。
文章目录
三、链表
3.1 链表介绍
- 链表是有序的列表，但是它在内存中的存储如下：
-
小结：
1. 链表是以节点的方式来存储,是链式存储；
2. 每个节点包含 data 域， next 域： 指向下一个节点；
3. 如图： 发现链表的各个节点不一定是连续存储；
4. 链表分带头节点的链表和没有头节点的链表， 根据实际的需求来确定
单链表(带头结点) 逻辑结构示意图如下 ：
- 定义链表
public class ListNode {
// 结点的值
int val;
// 下一个结点
ListNode next;
// 节点的构造函数(无参)
public ListNode() {
}
// 节点的构造函数(有一个参数)
public ListNode(int val) {
this.val = val;
}
// 节点的构造函数(有两个参数)
public ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
3.2 单链表的应用实例
package linkedlist;
public class SingleLinkedListDemo {
public static void main(String[] args) {
//进行测试
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero4);
//按照排名加入英雄
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero2);
//显示
singleLinkedList.list();
}
}
//定义SingleLinkedList管理英雄
class SingleLinkedList{
//先初始化一个头节点，头节点不要动，不存放具体数据
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向链表
//当不考虑编号的顺序时
//1.找到当前链表的最后节点
//2.将这个节点的next指向新的节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此需要一个辅助变量temp
HeroNode temp = head;
//遍历链表，找到最后
while(true){
if(temp.next == null){
break;
}
//如果没有找到最后，将temp后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;
}
//第二种添加英雄方式，根据排名将英雄插入到指定位置
public void addByOrder(HeroNode heroNode){
HeroNode temp = head;
boolean flag = false;//flag标志添加的标号是否存在，默认为false
while(true){
if(temp.next == null){
//说明temp已经在链表的最后
break;
}
if(temp.next.no > heroNode.no){
//位置找到，就在temp的后面插入
break;
}else if(temp.next.no == heroNode.no){
//说明希望添加的heroNode的编号已然存在
flag = true;
break;
}
temp = temp.next;//后移，遍历当前链表
}
if(flag){
//不能添加，说明编号已经存在
System.out.printf("准备插入的英雄的编号%d已经存在，不能加入\n", heroNode.no);
}else{
//插入到链表中，temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//显示链表
public void list(){
//判断链表是否为空
if(head.next == null){
System.out.println("链表空");
return;
}
//因为头节点不能动，需要一个辅助变量来遍历
HeroNode temp = head.next;
while(true){
if(temp == null){
break;
}
//输出节点的信息
System.out.println(temp);
//将temp后移
temp = temp.next;
}
}
}
//定义HeroNode, 每个HeroNode对象就是一个节点
class HeroNode {
public int no;
public String name;
public String nickname;
public HeroNode next;//指向下一个节点
public HeroNode(int no, String name, String nickname){
this.no = no;
this.name = name;
this.nickname = nickname;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
3.3 力扣刷题记录
3.3.1 移除链表元素
题意：删除链表中等于给定值 val 的所有节点。（203）
示例 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
输出：[]
- 思路
设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e5ARiPK7-1645411778214)(https://raw.githubusercontent.com/CarrieYpi/Typro_Image/master/img/image-20220220210301936.png)]
- 代码
class Solution {
public ListNode removeElements(ListNode head, int val) {
if(head == null){
return head;
}
//定义dummy头节点统一操作
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode temp = dummy;
while(temp.next != null){
//判断是否等于val
if(temp.next.val == val){
temp.next = temp.next.next;
}else{
//不是就后移temp
temp = temp.next;
}
}
return dummy.next;
}
}
3.3.2 反转链表
题意：反转一个单链表。（206）
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
- 思路
- 代码
class Solution {
public ListNode reverseList(ListNode head) {
//注意这里需要定义三个节点，一个指向头节点，一个用来保存头节点的下一位节点，一个用来指代null
ListNode cur = head;
ListNode prev = null;
ListNode temp = null;
while(cur != null){
//先保存下一个节点
temp = cur.next;
//再将当前节点反转指向前一个节点
cur.next = prev;
//将prev前移
prev = cur;
cur = temp;
}
//注意返回的值是prev,因为此时cur已经为null
return prev;
}
}
3.3.3 两两交换链表中的节点
题意：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。（24）
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
- 思路
设置虚拟头结点
- 代码
class Solution {
public ListNode swapPairs(ListNode head) {
//设置虚拟头结点
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode prev = dummy;
while(prev.next != null && prev.next.next != null){
//首先保存第三个节点
ListNode temp = head.next.next;
//虚拟头结点指向第二个节点
prev.next = head.next;
//第二个节点指向第一个节点
head.next.next = head;
//第一个节点指向第三个节点
head.next = temp;
//虚拟头结点后移
prev = head;
//头结点后移
head = head.next;
}
return dummy.next;
}
}
3.3.4 删除链表的倒数第N个节点
题意：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。（19）
-
思路
-
定义虚拟头结点
-
定义fast指针和slow指针，初始值分别为头结点和虚拟头结点
-
fast先走n步，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：（假设n=2）
- fast和slow同时移动，直到fast指向末尾
- 删除slow指向的下一个节点
-
-
代码
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
//定义虚拟头结点
ListNode dummy = new ListNode(0);
dummy.next = head;
//快指正
ListNode first = head;
//慢指针
ListNode second = dummy;
//快指针先走n次
for(int i = 0; i < n; i++){
first = first.next;
}
//快慢指针一起移动
while(first != null){
first = first.next;
second = second.next;
}
second.next = second.next.next;
return dummy.next;
}
}
3.3.5 链表相交
题意：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。（02.07.）
- 思路
- 看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：
- 我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置
此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。
否则循环退出返回空指针。
- 代码
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode curA = headA;
ListNode curB = headB;
int lenA = 0;
int lenB = 0;
//求链表A的长度
while(curA != null){
lenA++;
curA = curA.next;
}
//求链表B的长度
while(curB != null){
lenB++;
curB = curB.next;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头，lenA为其长度
if(lenB > lenA){
int tempLen = lenA;
lenA = lenB;
lenB = tempLen;
ListNode tempNode = curA;
curA = curB;
curB = tempNode;
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点上（末尾位置对齐）
//注意这里的gap--
while(gap-- > 0){
curA = curA.next;
}
// 遍历curA 和 curB，遇到相同则直接返回
while(curA != null){
if(curA == curB){
return curA;
}
curA = curA.next;
curB = curB.next;
}
return null;
}
}
3.3.6 环形链表
题意：给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。（142）
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
- 思路
主要考察知识点：
- 判断链表是否环
- 如果有环，如何找到这个环的入口
- 判断链表是否环
- 可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
- **为什么fast指针和slow指针一定会相遇呢？**这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。
- 如果有环，如何找到这个环的入口
- 从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
- 且在慢指针走的第一圈就会相遇。
- 代码
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
//有环
if(fast == slow){
ListNode index1 = fast;
ListNode index2 = head;
//找到环的入口
while(index1 != index2){
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}
扫一扫
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
