welcome to my blog
剑指offer面试题18(java版):删除链表的节点
务必掌握题目二的进阶代码
题目二的进阶代码
题目二的进阶代码(递归版本)
题目一描述
在O(1)时间内删除链表节点.
给定单向链表的头指针和一个节点指针, 定义一个函数在O(1)时间内删除该节点.链表节点定义如下:
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
思路
- 常规思路: 删除一个节点, 让待删节点的前一个节点指向待删节点的下一个节点
- 寻找待删节点的前一个节点的时间复杂度是O(n),不满足O(1)的要求
- 另一种思路: 将待删节点的value改成待删节点的下一个节点的value, 然后将待删节点指向下一个节点的下一个节点.
- 上面这种思路不需要寻找待删节点的上一个节点, 时间复杂度是O(1)
- 链表问题特别要注意的是: 末尾节点; 只有一个节点的链表
- 待删节点为末尾节点时, 只能从头开始找到末尾节点的上一个节点, 将该节点指向null
- 链表只有一个节点时, 直接将头指针指向null
复杂度
- 时间复杂度: O(1)
- 空间复杂度: O(1)
public class MST18 {
public static void main(String[] args) {
}
public static class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public static void deleteNode(ListNode pHead, ListNode pToBeDeleted)
{
// 健壮性判断
if(pHead == null || pToBeDeleted == null)
throw new RuntimeException("链表为空或未指定待删除节点");
// 正常执行
/*
1. sp:链表只有一个节点, 头指针指向null即可
2. sp:删除最后一个节点, 找出倒数第二个节点并让该节点指向null
3. 令待删节点的value等于待删节点下一个节点的value, 并令待删节点指向下一个节点的下一个节点
*/
//1.
if(pHead.next == null)
pHead = null;
//2.
ListNode temp = pHead;
if(pToBeDeleted.next == null){
while(temp.next != pToBeDeleted)
temp = temp.next;
temp.next = null;
}
//3.
temp = pToBeDeleted.next;
pToBeDeleted.val = temp.val;
pToBeDeleted.next = temp.next;
}
}
题目二描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
第四次做; 递归版; 和循环版的处理思路相同, 核心: 1) 脑中要有p1,p2,p3三个指针, pHead相当于p2, cur相当于p3, 没有p1 2)递归函数逻辑, 判断当前节点是否重复(当前条件), 不重复的话, 当前节点指向剩余的处理好的链表(新条件新递归); 重复的话, 找到第一个和当前节点不相等的节点, 返回以该节点开头的处理后的链表(新条件新递归)
public class Solution {
//递归函数逻辑: 找到第一个不重复的节点(当前条件), 该节点指向剩余的已经处理好的链表(新条件新递归)
public ListNode deleteDuplication(ListNode pHead)
{
//base case
if(pHead==null || pHead.next==null)
return pHead;
ListNode cur = pHead.next;
if(cur.val!=pHead.val){
pHead.next = deleteDuplication(cur);
return pHead;
}
//cur.val==pHead.val
else{
while(cur!=null && cur.val==pHead.val){
cur = cur.next;
}
//here, cur==null || cur.val!=pHead.val
return deleteDuplication(cur);
}
}
}
第四次做;核心:1)固定最后一个不重复的值, 使用双指针判断该值的下一个值是否重复 2)指针的含义: p1指向最后一个不重复的节点; p2指向p1的下一个节点,p3指向p2的下一个节点, p3用于检测p2是否重复 3)循环结束条件, p1,p2,p3只能往右移动,所以如果p3走到null就不用继续判断了 4)使用指针要随时检查是否越界 5)dummy节点
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead==null || pHead.next==null)
return pHead;
ListNode dummy = new ListNode(0);
dummy.next = pHead;
//核心: 指针的含义: p1指向最后一个不重复的节点; p2指向p1的下一个节点,p3指向p2的下一个节点, p3用于检测p2是否重复
ListNode p1=dummy, p2=pHead, p3=pHead.next;
//核心:循环结束条件, p1,p2,p3只能往右移动,所以如果p3走到null就不用继续判断
while(p3!=null){
//p1的下一个节点p2不重复
//核心:p3可能会指向null, 要注意检查; 使用指针要随时检查是否越界
if(p3!=null && p3.val != p2.val){
//p2成为最后一个不重复的节点
p1 = p2;
p2 = p3;
p3 = p3==null? null : p3.next;
}
//p1的下一个节点p2出现重复
else if(p3!=null){
while(p3!=null && p3.val == p2.val){
p3 = p3.next;
}
//here, p3==null || p3.val != p2.val
p1.next = p3;
//update
p2 = p3;
p3 = p3==null ? null : p3.next;
}
//p3==null, 不需要操作了
}
return dummy.next;
}
}
思路
- 条件判断太多! 试错了好多次才成功, 如何在思考问题时就能将条件组合的很完备? 暂时的理解是: 考虑常规情况, 考虑所有特殊情况
收获
- while条件用什么? 对于链表来说, 可以这样: PCurr != null; 这样while循环就会处理所有的节点
- if中多个条件的不同组合
- 链表问题中, 用到pCurr.next时,大都需要判断pCurr.next是否为null
第三次做, 脑子有点混乱, 但还是一遍过了; 递归函数的逻辑:返回删除重复节点后的链表的头结点; 每个节点的处理逻辑是相同的, 只不过出现重复节点的时候会在一次递归中全部处理; 以pHead开头的链表,如果重复就找第一个值不等于pHead.val的节点, 以此节点为开头调用递归函数并返回; 如果不重复就让pHead.next指向以pHead.next为头结点的链表的第一个不重复节点
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead==null||pHead.next==null)
return pHead;
ListNode right = pHead.next;
if(right!=null && pHead.val == right.val){
while(right!=null && right.val==pHead.val)
right = right.next;
return deleteDuplication(right);
}
else{
pHead.next = deleteDuplication(right);
return pHead;
}
}
}
第三次做, 还没吃透这道题; 注意left的更新方式: curr.val!=right.val时, 更新left, curr.valright.val时,更新left.next; 注意right的更新方式, 如果curr.valright.val, 那么right自己一直移动到null或者val!=curr.val的节点;
/*
这道题本来是要先处理头结点,再处理非头结点的, 可以创建一个临时节点,指向头结点,
这样,原来的头结点就变成了非头结点, 可以用一套流程处理原来所有的节点
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead==null)
return null;
ListNode tempHead = new ListNode(pHead.val);//初始值有讲究
tempHead.next = pHead;
ListNode left=tempHead, curr=pHead, right;
while(curr!=null){
//save
right = curr.next;
//execute
if(right!=null && curr.val==right.val){//注意检查null
while(right!=null && right.val==curr.val)
right = right.next;
left.next = right;
curr = right;
}
else{
left = curr;
curr = right;
}
}
return tempHead.next;
}
}
第二次做, 递归版; 在一次递归中处理多个连续重复节点
/*
一次递归调用中会一次性处理完当前节点连接的相邻重复节点
递归逻辑:在pHead, pHead.next,...,null这段链表中,
如果pHead是重复的节点,那么返回curr,...,null这段链表中第一个非重复节点; 其中curr是不等于pHead值的最近的节点
如果pHead不是重复的节点,那么pHead.next指向curr,...,null这段链表中第一个非重复节点; 其中curr是pHead.next
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
//base case
//当前节点是最后一个节点, 一定有当前节点和上一个节点值不相等
//如果相等的话在上一轮递归中就考虑了本节点
if(pHead==null || pHead.next==null)
return pHead;
//
ListNode curr = pHead.next;
if(curr.val == pHead.val){
curr = curr.next;
while(curr!=null && curr.val==pHead.val)
curr = curr.next;
return deleteDuplication(curr);
}
else{
//pHead.next指向curr....null这段链表中第一个不重复的节点
pHead.next = deleteDuplication(curr);
return pHead;
}
}
}
第二次做, 核心:创建一个节点指向pHead,这样就能将pHead按照普通节点处理了; 改动了链表指向,使用三个指针, left的更新比较特殊: left.val != curr.val != right.val时才更新left; 此外,curr和right也不一定是挨着的
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead==null || pHead.next == null)
return pHead;
//
ListNode head = new ListNode(0);
head.next = pHead;//这样就能用一套流程处理头节点和非头节点了! 这是一种思想
ListNode left=head, curr=pHead, next;
int temp;
while(curr != null){
next = curr.next;
temp = curr.val;
if(next != null && next.val == temp){
next = next.next;
while(next!=null && next.val == temp)
next = next.next;
left.next = next; //也能让最后一个节点指向null
curr = next;
}
else{
left = curr;
curr = next;
}
}
return head.next;
}
}
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public static ListNode deleteDuplication(ListNode pHead) {
/*
初始化pPre指向pHead, pCurr指向pHead.next, 重复标志位duplicated, 初始值false,表示当前没有重复
sp1:链表只有一个节点, 直接return Head
sp2:
1.
*/
// valid check
if (pHead == null)
return null;
// sp1
if (pHead.next == null)
return pHead;
// normally execution
ListNode pPre = pHead;
ListNode pCurr = pHead.next;
boolean duplicated = false;
// ensure pHead.val != pHead.next.val
while (pHead != null) {
if (pHead.next != null && pHead.val == pHead.next.val) {
duplicated = true;
pHead = pHead.next;
} else if (pHead.next != null && pHead.val != pHead.next.val && duplicated) {
pHead = pHead.next;
duplicated = false;
}
else if (pHead.next != null && pHead.val != pHead.next.val)
break;
else if (pHead.next == null && !duplicated)
break;
else if(pHead.next == null )
pHead = null;
}
//
while (pCurr != null) { // 使用该条件确保while循环能够处理到最后一个节点
if (pCurr.next == null && duplicated) {
pPre.next = null;
pCurr = null;
} else if (pCurr.next == null && !duplicated) {
pPre.next = pCurr;
pCurr = null;
}
// 执行到这里, pCurr.next != null
else if (pCurr.val == pCurr.next.val) {
duplicated = true;
pCurr = pCurr.next;
} else if (pCurr.val != pCurr.next.val && duplicated) {
duplicated = false;
pCurr = pCurr.next;
} else if (pCurr.val != pCurr.next.val && !duplicated) {
pPre.next = pCurr; // 删除重复节点
pPre = pCurr;
pCurr = pCurr.next;
}
}
return pHead;
}
}
题目二的进阶代码
思路
- 指针指向一个节点, 如果要使用本节点的val,那么就得判断本节点是否为null; 如果不适用本节点的val,那么就不用判断本节点是否为null
- 如何解决头节点重复问题? 创建一个节点head, 让head.next=pHead, 这样在执行主体函数时,如果pHead是重复节点,那么head.next会指向第一个不重复的节点或者指向末尾的null. 其实这样做的话,最大的好处是可以用处理普通节点的方法处理头节点, 也就是头节点和非头节点都可以用同一套流程进行处理
- 要不要单独处理链表的末尾null
- 判断重复节点的时候,最好不要判断相邻的节点值是否相同,最好是创建一个新的节点pNext, 向后移动pNext,直到pNext的值不等于pCurr
- pPre一定比pCurr慢, pPre.next一定会指向非重复的pCurr. 所以当pCurr==null时说明链表处理完毕! 仔细理解这句
- 一定要明确什么时候才会改变pPre.next的指向! 当且仅当pPre.val != pCurr.val 同时pCurr.val != pNext.val时
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
// input check
if(pHead == null)
return null;
// execute
ListNode head = new ListNode(0); //head在pHead前面, 如果LinkList全是重复的,则head指向null; 否则指向pHead
head.next = pHead;
ListNode pPre = head; // pPre一定比pCurr慢
ListNode pCurr = pHead;
while(pCurr!=null){
int val = pCurr.val;
ListNode pNext = pCurr.next;
if(pNext != null && pNext.val == val){
while(pNext != null && pNext.val == val){
pNext = pNext.next;
}
pPre.next = pNext;
pCurr = pNext;
}
else{
pPre.next = pCurr;
pPre = pCurr;
pCurr = pCurr.next;
}
}
return head.next;
}
}
题目二的进阶代码(递归版本)
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
// 递归版本. 功能: 从当前节点开始,找到下一个非重复节点并返回; 递归终止条件:当前节点是链表末尾null或者当前节点是链表最后一个节点
// input check
if(pHead == null)
return null;
if(pHead.next == null)
return pHead;
// 执行到这里, 链表至少两个节点
// 判断节点是否重复,需要用到节点的值. 相邻两节点值的关系: 相等, 不相等, 所以用if else就能将这两大类情况考虑完备
ListNode pCurr = pHead.next;
if(pCurr.val == pHead.val){
while(pCurr != null && pCurr.val == pHead.val){
pCurr = pCurr.next;
}
// while循环外, pCurr可能是null, 也可能不是null
// 继续递归
// 是null的话,下一次递归返回null,返回的null将会被上一个非重复节点所指向
// 不是null的话, 下一次继续递归将会继续从当前节点开始寻找下一个非重复节点
return deleteDuplication(pCurr); // 弄清楚返回给谁!
}
else{ // pHead.next.val != pHead.val
pHead.next = deleteDuplication(pCurr);
return pHead;
}
}
}
扫一扫
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
