理论:
1、线性表的链式存储
1.1 链式存储
用一组任意的存储单元存储线性表的元素,这组单元可以是连续的,也可以是不连续的。
每一个数据元素包含数据域和指针域,数据域存储数据元素信息,指针域存储后续数据元素的存储地址。数据域和指针域共同组成结点(Node)
1.2 相关概念
头结点和头指针:
头指针:链表中第一个结点的存储位置(有头结点时为头结点,无头结点是为第一个元素结点(开始结点));头指针具有标识作用,所以常常会用头指针冠以链表的名字;无论链表是否为空,头指针均存在,头指针是链表的必要元素。
头结点:在单链表第一个结点前可以附设一个结点,称为头结点;头结点的数据域可以不存储数据,也可以存储链表长度等信息,指针域存储链表的头指针(第一个结点的存储位置)。
链表为空:
2、单链表:
每个结点中只包含一个指针域的链表。
3、其他链表:
3.1 静态链表
用数组描述的链表叫做静态链表,描述方法称为游标实现法
3.2 循环链表
将链表终点结点的指针域由空指针改为指向头结点
3.3 双向链表
练习:
203.移除链表元素
1、题目
给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
示例 1:
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
2、解题
Key:设置虚拟头结点以统一原有头结点和其他结点的删除操作
public class Solution {
public ListNode RemoveElements(ListNode head, int val)
{
if(head == null)
{
return null;
}
else
{
//set a dummy node
ListNode dummy = new ListNode(0);
dummy.next = head;
//set point
ListNode prev = dummy;
ListNode cur = head;
//loop
while(cur != null)
{
if(cur.val == val)
{
prev.next = cur.next;
}
else
{
prev = cur;
}
cur = cur.next;
}
return dummy.next;
}
}
}
3、总结
错误:
prev.next = cur
忘记删除操作是基于已经存在的链表,prev.next 本来即为cur;
prev和cur是遍历链表的指针,随着循环进行更新;
//loop
while(cur != null)
{
if(cur.val == val)
{
prev.next = cur.next;
}
else
{
prev.next = cur;
}
cur = cur.next;
}
707.设计链表
1、题目
你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:val 和 next 。val 是当前节点的值,next 是指向下一个节点的指针/引用。
如果是双向链表,则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。实现 MyLinkedList 类:
MyLinkedList() :初始化 MyLinkedList 对象。
int get(int index) :获取链表中下标为 index 的节点的值。如果下标无效,则返回 -1 。
void addAtHead(int val) :将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。
void addAtTail(int val) :将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val): 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度,那么该节点会被追加到链表的末尾。如果 index 比长度更大,该节点将 不会插入 到链表中。
void deleteAtIndex(int index): 如果下标有效,则删除链表中下标为 index 的节点。
示例:
输入:
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出:
[null, null, null, null, 2, null, 3]
解释:
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在,链表变为 1->3
myLinkedList.get(1); // 返回 3
2、解题
public class MyLinkedList {
public class ListNode
{
public int val;
public ListNode next;
public ListNode(int val = 0, ListNode next = null)
{
this.val = val;
this.next = next;
}
}
private ListNode head;
private int size;
public MyLinkedList() {
this.head = null;
this.size = 0;
}
public int Get(int index) {
if(index < 0 || index >= this.size)
{
return -1;
}
else
{
int i = 0;
ListNode cur = this.head;
while(i < index)
{
cur = cur.next;
i ++;
}
return cur.val;
}
}
public void AddAtHead(int val) {
ListNode newHead = new ListNode(val);
newHead.next = this.head;
this.head = newHead;
this.size ++;
}
public void AddAtTail(int val) {
if(head == null)
{
AddAtHead(val);
return;
}
ListNode cur = this.head;
while(cur.next != null)
{
cur = cur.next;
}
cur.next = new ListNode(val);
size ++;
}
public void AddAtIndex(int index, int val) {
if(index < 0 || index > this.size)
{
return;
}
if(index == 0)
{
this.AddAtHead(val);
return;
}
ListNode newNode = new ListNode(val);
ListNode prev = null;
ListNode cur = head;
for(int i = 0; i < index; i ++)
{
prev = cur;
cur = cur.next;
}
newNode.next = cur;
prev.next = newNode;
size ++;
}
public void DeleteAtIndex(int index) {
if(index < 0 || index >= this.size)
{
return;
}
if(index == 0)
{
head = head.next;
this.size --;
return;
}
ListNode prev = this.head;
int i = 0;
while(i < index -1)
{
prev = prev.next;
i ++;
}
prev.next = prev.next.next;
size --;
}
}
3、总结
1、简单错误:
0 < index < size 写法不对,不等式需要分开;
若智啊!!!while循环里记得i++啊!!!!!!!!!!!!!!!!!!!!!!!!!
2、所有链表元素增减操作及时更新链表size;
3、所有操作建议第一步先单独讨论参数无效的情况(如index < 0 || index > size)
4、AddAtTail
没有判断链表为空的情况;
寻找链表最后一个结点可以以cur . next 不为空为loop条件
public void AddAtTail(int val)
{
ListNode newEnd = new ListNode(val);
ListNode lastNode = this.head;
for(int i = 0; i < this.size; i ++)
{
lastNode = lastNode.next;
}
lastNode.next = newEnd;
}
5、AddAtIndex
单独判断Index无效的情况;
单独判断插入头结点的情况但不需要单独判断插入终端结点?
类似删除节点中,设置虚拟头结点可以统一操作,否则单独写头结点的操作
插入思路:(注意是将index位的结点替换为newnode,而不是再index位后插入newnode)
1)同时找到index位的前驱结点prev和后继结点cur,用newnode替换cur。
2)只找到index位的前驱结点prev,先设置newnode的后继结点,再将newnode设为prev的后继结点,注意顺序。
public void AddAtIndex(int index, int val)
{
ListNode newNode = new ListNode(val);
ListNode cur = this.head;
int i = 0;
if(0 < index && index < this.size)
{
while(i < index - 1)
{
cur = cur.next;
i ++;
}
newNode.next = cur.next;
cur.next = newNode;
}
else if(index == 0)
{
this.AddAtHead(val);
}
else if(index == this.size)
{
this.AddAtTail(val);
}
else
{
return;
}
}
6、DeleteAtIndex
单独判断index无效的情况;
单独写删除头结点的情况;
public void DeleteAtIndex(int index) {
if(index == 0)
{
this.head = this.head.next;
}
else if(0 < index && index < this.size)
{
int i = 0;
ListNode cur = this.head;
while(i < index - 1)
{
cur = cur.next;
i ++;
}
cur.next = cur.next.next;
}
else
{
return;
}
}
7、思路
用for循环或while循环查找某个位置或某个值的结点,前驱和后继结点,开始和终端结点
对节点进行删除或替换(插入)操作
单独讨论情况:index无效;头结点(也可以使用虚拟头结点)操作;链表为空时()
206.反转链表
1、题目
给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
2、解题
递归法:
3、总结
1、递归法纠错
2、双指针法
注意用temp存储cur.next
public class Solution {
public ListNode ReverseList(ListNode head) {
ListNode pre = null;
ListNode cur = head;
while(cur != null)
{
ListNode temp = cur.next;
cur.next = pre;
pre = cur;
cur = temp;
}
head = pre;
return head;
}
}
3、实质就是指针指向反转,不要若智的以为是结点位置的互换!!!
24. 两两交换链表中的节点
1、题目
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4]
输出:[2,1,4,3]
2、解题
public class Solution {
public ListNode SwapPairs(ListNode head) {
//set dummy head
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
//
ListNode cur = dummyHead;
while(cur.next != null && cur.next.next != null)
{
//set temp
ListNode temp1 = cur.next;
ListNode temp2 = cur.next.next.next;
//change
cur.next = cur.next.next;
cur.next.next = temp1;
cur.next.next.next = temp2;
//
cur = cur.next.next;
}
return dummyHead.next;
}
}
3、总结
画图解决问题:
19.删除链表的倒数第N个节点
1、题目
给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
示例 1:
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
2、解题
二次扫描
public class Solution {
public ListNode RemoveNthFromEnd(ListNode head, int n) {
int size = 0;
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode cur = dummyHead;
while(cur != null)
{
size ++;
cur = cur.next;
}
cur = dummyHead;
for(int i = 0; i < size - n - 1; i ++)
{
cur = cur.next;
}
cur.next = cur.next.next;
return dummyHead.next;
}
}
3、总结
1、注意:
for循环条件:i < size - n - 1(要定位删除结点的前驱结点)
2、双指针写法:
public class Solution {
public ListNode RemoveNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode first = dummy;
ListNode second = dummy;
// 将 first 指针向前移动 n+1 步
for (int i = 0; i <= n; i++) {
first = first.next;
}
// 继续同时移动 first 和 second 指针,直到 first 指针到达链表末尾
while (first != null) {
first = first.next;
second = second.next;
}
// 删除倒数第 n 个节点
second.next = second.next.next;
return dummy.next;
}
}
面试题 02.07. 链表相交
1、题目
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
图示两个链表在节点 c1 开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
2、解题
3、总结
142.环形链表II
1、题目
给定一个链表的头节点
head
,返回链表开始入环的第一个节点。 如果链表无环,则返回null
。如果链表中有某个节点,可以通过连续跟踪
next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果pos
是-1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。不允许修改 链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点解释:链表中有一个环,其尾部连接到第二个节点。
2、解题
3、总结
1、思路推导:
Key:快慢指针为什么第一圈一定相遇;快指针为什么不会跳过慢指针;x和z的关系
2、