首页 > 试题广场 >

访问单个节点的删除

[编程题]访问单个节点的删除

热度指数：17811 时间限制：C/C++ 3秒，其他语言6秒空间限制：C/C++ 32M，其他语言64M
算法知识视频讲解

给定一个单向链表中的某个节点，请删除这个节点，但要求只能访问该节点。若该节点为尾节点，返回false，否则返回true

说明：本题目包含复杂数据结构ListNode，点此查看相关信息

算法知识视频讲解

MichaelTim

//先判断，再删除
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if(pNode == NULL || (pNode != NULL &&  pNode->next == NULL )) return false;
        
        pNode->val = pNode->next->val;
        pNode->next = pNode->next->next;
        delete pNode->next;
        return true;
    }
};

发表于 2016-05-05 17:15:04 回复(3)

C/C++

JOHNNIE

首先，不能访问之前的节点，但是可以访问后续节点。

然后，对于尾节点，直接delete掉，返回false即可。

最后，对于中间节点简记为A = pNode，利用其后续节点B = pNode->next和C = pNode->next->next变相删除。

即 A--->B--->C，要删除A。这样变相删除：把B的值给A的值域，把C的地址赋给A的地址域。

class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        // 尾节点
        if (pNode->next == NULL)
            {
            delete pNode;
            return false;
        }
        else
            {
            ListNode* nextNode;
            nextNode = pNode->next;
            pNode->val = nextNode->val;
            pNode->next = nextNode->next;
            delete nextNode;
            return true;
        }
    }
};

发表于 2016-08-14 12:02:20 回复(3)

Howie59


	public classRemove {



	    public boolean removeNode(ListNode pNode) {



	        if(pNode ==null|| pNode.next ==null)return false;



	        return true;



	    }



	}



	



	



	这样居然也可以

发表于 2018-08-27 15:36:14 回复(2)

Smile201802051405267

删除中间节点，将后面结点值赋给他，然后直接删除后面结点。

注意只能这样删除中间节点，尾结点无法删除。

import java.util.*;

/*
public class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}
}*/
public class Remove {
public boolean removeNode(ListNode pNode) {
// write code here
if(pNode.next==null){
return false;
}
pNode.val=pNode.next.val;
pNode.next=pNode.next.next;
return true;
}
}

发表于 2018-03-09 09:49:10 回复(0)

drdr

    bool removeNode(ListNode* pNode) {
        // write code here
        if(pNode==NULL || pNode->next == NULL) return false;
        ListNode* tmp = pNode->next;
        pNode->val = tmp->val;
        pNode->next = tmp->next;
        delete tmp;   //回收
        return true;
    }

发表于 2017-08-17 16:08:28 回复(0)

class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if (pNode->next == NULL || pNode == NULL)
        {
            return false;
        }
        ListNode *front;
        front = pNode;
        front->next=pNode;
        front->next=pNode->next;
        pNode->next=NULL;
        delete pNode;
        return true;
    }
};

发表于 2020-02-06 19:59:14 回复(0)

木然猫猫

class Remove {
public:
    bool removeNode(ListNode* pNode) {
        ListNode* qNode = pNode->next;
        if (!qNode) { return false; }
        // swap
        pNode->val ^= qNode->val;
        qNode->val ^= pNode->val;
        pNode->val ^= qNode->val;
        // delete
        pNode->next = qNode->next;
        qNode->next = nullptr;
        delete qNode;
        return true;
    }
};

发表于 2018-12-22 22:07:55 回复(0)

Salmon-William

刚开始题目有点没看懂，真是对不起小学老师hh，结果思考一会后，发现就是判断这个节点是否为空

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        if(!pNode->next)
            return false;
            return true;
    }
};

发表于 2017-08-29 16:11:27 回复(1)

此广告位出租

把下一个节点删了，在删之前把它的值拿了，可能这就是命吧

    if (pNode.next == null) return false;
    pNode.val = pNode.next.val;
    pNode.next = pNode.next.next;
    return true;

编辑于 2017-07-28 22:17:17 回复(0)

InGodWeTrust

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
		ListNode cur=pNode;
        if(cur.next==null)	return false;
        else
        	return true;
    }
}

发表于 2017-07-17 20:36:55 回复(1)

luozijian

struct ListNode {

int val;

struct ListNode *next;

ListNode(int x) : val(x), next(NULL) {}

};*/

class Remove {

public:

bool removeNode(ListNode* pNode) {

// write code here

if(!pNode || !pNode->next){

return false;

}

ListNode* p = pNode->next;

pNode->val = p->val;

pNode->next = p->next;

return true;

}

};

发表于 2017-05-22 21:29:07 回复(0)

阿狸不是猫

import java.util.*;
//仅检测了是不是尾节点，因为我真的没看懂前面描述的和后面有什么关系，而且还通过了
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode !=null&&pNode.next ==null){
            return false;
        }else{
            return true;
        }
    }
}
运行时间：33ms
占用内存：709k

发表于 2017-05-16 16:16:38 回复(2)

绝对凌度

我觉得题目就是让检测这个节点是不是尾节点。。。两行代码通过。。。
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode == null || pNode.next == null) return false;
        return true;
    }
}

发表于 2017-04-26 18:51:48 回复(1)

Java

未缘

import java.util.*;

public class ListNode {

int val;

ListNode next = null;

ListNode(int val) {

this.val = val;

}

}*/

public class Remove {

public boolean removeNode(ListNode pNode) {

if(pNode.next==null)

return false;

ListNode next_node= pNode.next;

// 将待删除节点的下一个节点的值赋值给待删除的节点，然后删除待删除节点的下一个节点

pNode.val=next_node.val;

pNode.next=next_node.next;

// 将下一个节点赋值为null 让GC回收

next_node=null;

return true;

}

发表于 2017-03-26 14:59:55 回复(0)

Java

YiBuLZ

本题高票答案一定是看了C语言的实现，才那样写的。
在Java中的引用和C语言的指针是不一样的。

public class Remove {
    public boolean removeNode(ListNode pNode) {
        // write code here
        if (pNode == null) {
            return false;
        }
        if (pNode.next == null) {
            pNode = null;
            return false;
        } else {
            pNode = pNode.next;
        }
        return true;
    }
}

编辑于 2017-03-23 13:46:07 回复(0)

Python

Yannyezixin

思路：正常的删除一个结点思路是，给定一个链表头和一个结点。当访问到指定结点pNode时，即pHead->next 等于指定结点, pHead->next = pNode->next->next

但是现在不能访问到指定结点的前一个结点，那么可以这样做

将当前结点的下一个结点覆盖当前结点，然后删除下一个结点。变相的达到删除指定结点的目的

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Remove:
    def removeNode(self, pNode):
        if not pNode or not pNode.next:
            return False
        
        pNode.val = pNode.next.val
        pNode.next = pNode.next.next
        
        return True

发表于 2016-08-01 21:07:05 回复(0)

从前从前有个人爱你很久

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
        if(pNode.next == null){
            return false;
        }else{
            pNode.val = pNode.next.val;
            pNode.next = pNode.next.next;
            return true;
        }
    }
}

编辑于 2017-04-05 20:26:23 回复(0)

xiao_lai

class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        if(pNode->next==NULL){
            return false;
        }else{
            //由于是单向链表，所以访问不到前一个节点，只能获取pNode节点之后的所有节点
            //为了实现删除效果，可以把后续节点的值都依次往前复制，最终删除最后一个节点
            ListNode *cur=pNode,*post=cur->next;
            /*
            while(post){
                if(post->next==NULL)break;
                cur->val=post->val;
                cur=post;
                post = post->next;
            }
            cur->next=NULL;
            */
            if(post){
                cur->val=post->val;
                cur->next=post->next;
            }
            delete post;
            return true;
        }
    }
};

编辑于 2016-07-25 13:40:40 回复(2)

KingSit

有bug，这样也过了

if( pNode->next == NULL) return false;

else

return true;

发表于 2016-04-12 21:45:12 回复(2)

Aurora1

public boolean removeNode(ListNode pNode) {
		return pNode.next != null; //excited!
}

编辑于 2016-04-04 11:01:15 回复(0)

提交观点

问题信息

编程基础链表

难度：

114条回答 132收藏 29260浏览

通过挑战的用户

查看代码

在debug的...

2023-01-12 13:30:59
靓仔很忙

2022-12-16 20:14:06
一枚小菜总

2022-12-07 18:26:41
PoonCyun

2022-10-19 09:54:03
牛客38465...

2022-09-10 17:35:29

访问单个节点的删除

说明：本题目包含复杂数据结构ListNode，点此查看相关信息

问题信息

热门推荐

通过挑战的用户

相关试题