【LeetCode链表#7】设计一个链表并实现常见的操作方法
设计链表
题目
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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
这题有点特殊，与其说是题不如说是熟悉如何实现操控链表的常见方法
参考https://www.cnblogs.com/DAYceng/p/17047323.html中的实例代码以及题题目给的模板得知
我们需要先自行定义节点类ListNode并初始化链表，这里使用的是单链表，定义如下：
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;
}
}
class MyLinkedList {
int size;//链表节点个数
ListNode dummy;//定义虚拟头节点
//用于初始化一个链表
public MyLinkedList() {
//初始化链表的size和虚拟头节点
size = 0;
dummy = new ListNode(0);
}
public int get(int index) {
}
public void addAtHead(int val) {
}
public void addAtTail(int val) {
}
public void addAtIndex(int index, int val) {
}
public void deleteAtIndex(int index) {
}
}
题目需要实现五个函数，下面逐一介绍
首先需要明确几点：
1、题目中，index是从0开始的，也就是说头节点的值也应该能够获取
2、统一使用虚拟节点，方便进行CRUD
获取第n个节点的值
思路
获取链表的值不能带入其他数据结构的思维
获取链表的值的方式就是遍历链表（这也是链表相对于数组的一大缺陷，慢）
要哪个节点就要从头节点遍历到那个才行
基于此，我们便可以开始设计这个方法了
不过还有几个点需要注意：
- 需要考虑n的范围（小于0不行，大于链表size-1也不行）
- 不能直接操作头节点，要不然找不回来原有的链表了
代码实现
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;
}
}
class MyLinkedList {
int size;//链表节点个数
ListNode dummy;//定义虚拟头节点
//用于初始化一个链表
public MyLinkedList() {
//初始化链表的size和虚拟头节点
size = 0;
dummy = new ListNode(0);
}
public int get(int index) {
//排除非法范围的n
if(index < 0 || index > size - 1){
return -1;
}
//定义当前节点cur
ListNode cur = dummy;
//遍历链表直到找到第index个节点
for(int i = 0; i <= index; i++){
cur = cur.next;
}
return cur.val; //返回该节点的值
}
...
}
ps：
在C++中可以用"while+运算式"来遍历，如下：
while(index){
cur = cur.next;
index--;
}
在Java中好像不能这么写，Java中的while需要的是一个条件式
头部插入节点
（按解题的思路顺序，应该先解决“第n个节点前插入节点”）
思路
如果搞清楚怎么在第n个节点前插入节点，这里的做法其实是一样的
代码实现
public void addAtHead(int val) {
//写法1：直接调用addAtIndex
//addAtIndex(0, val);
//写法2：
ListNode pre = dummy;//虚拟节点
ListNode cur = dummy.next;//这个才是真正的“头节点”所在的位置
//新建一个节点
ListNode node4add = new ListNode(val);
node4add.next = pre.next;
pre.next = node4add;
size++;
}
尾部插入节点
（按解题的思路顺序，应该先解决“第n个节点前插入节点”）
思路
同理
代码实现
public void addAtTail(int val) {
//写法1：直接调用addAtIndex
//addAtIndex(index, val);
//写法2：直接遍历链表，然后在末尾加
// ListNode pre = dummy;//虚拟节点
// ListNode cur = dummy.next;//这个才是真正的“头节点”所在的位置
ListNode cur = dummy;
while(cur.next != null){//遍历结束条件是遇到next为空的节点
cur = cur.next;
}
ListNode node4add = new ListNode(val);
cur.next = node4add;
size++;
}
ps：寻找末尾节点的遍历结束条件是遍历到.next为null的节点
第n个节点前插入节点
//在指定位置前插入新的节点
//要求
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
思路
0、判定index是否合法
1、先找到第n个节点
2、然后将新创建的节点的next指向pre节点（指向dummy）的next（如果是只定义cur，cur指向dummy，那就是指向cur.next）
或者
代码实现
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;
}
}
class MyLinkedList {
int size;//链表节点个数
ListNode dummy;//定义虚拟头节点
//用于初始化一个链表
public MyLinkedList() {
//初始化链表的size和虚拟头节点
size = 0;
dummy = new ListNode(0);
}
...
//在指定位置前插入新的节点
//要求
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
public void addAtIndex(int index, int val) {
//先判定index是否合法
if(index > size){
return;
}else if(index < 0){
index = 0;
}
//有两种写法：使用临时节点变量pre指代dummyhead+cur指代当前节点、直接使用一个cur
// //写法1：
// ListNode pre = dummy;
// ListNode cur = dummy.next;
// //遍历寻找待修改的节点
// for(int i = 0; i < index; i++){
// pre = cur;
// cur = cur.next;
// }
// //找到了就开始插
// //新建用来插入的节点
// ListNode node4add = new ListNode(val);
// //按步骤插入
// node4add.next = pre.next;
// pre.next = node4add;
// size++;
// //写法2：
ListNode cur = dummy;
//遍历找点
for(int i = 0; i < index; i++){
cur = cur.next;
}
//新建用来插入的节点
ListNode node4add = new ListNode(val);
node4add.next = cur.next;
cur.next = node4add;
size ++;
}
...
}
ps：别忘了size ++;
删除第n个节点
思路
cur指向A节点（dummy节点），记住，当前节点应该是cur的下一个节点，即B节点（cur.next）
删除当前第n个节点就是删除cur.next
那么只需要把cur的下一个节点的地址指向B的下一个节点，即C节点（cur.next.next）
代码实现
public void deleteAtIndex(int index) {
if(index < 0 || index >= size){
return;
}
size--;
//还是先找到要删除的节点
// ListNode pre = dummy;
// ListNode cur = dummy.next;
ListNode cur = dummy;
// while(index){
// cur = cur.next;
// }
for(int i = 0; i < index; i++){
cur = cur.next;
}
//找到后开始删除
// pre.next = cur.next;
// cur.next = null;
cur.next = cur.next.next;
}
完整代码
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;
}
}
class MyLinkedList {
int size;//链表节点个数
ListNode dummy;//定义虚拟头节点
//用于初始化一个链表
public MyLinkedList() {
//初始化链表的size和虚拟头节点
size = 0;
dummy = new ListNode(0);
}
public int get(int index) {
if(index < 0 || index > size - 1){
return -1;
}
//定义当前节点cur
ListNode cur = dummy;
// while(index){
// cur = cur.next;
// index--;
// }
for(int i = 0; i <= index; i++){
cur = cur.next;
}
return cur.val;
}
public void addAtHead(int val) {
//写法1：直接调用addAtIndex
//addAtIndex(0, val);
//写法2：
ListNode pre = dummy;//虚拟节点
ListNode cur = dummy.next;//这个才是真正的“头节点”所在的位置
//新建一个节点
ListNode node4add = new ListNode(val);
node4add.next = pre.next;
pre.next = node4add;
size++;
}
public void addAtTail(int val) {
//写法1：直接调用addAtIndex
//addAtIndex(index, val);
//写法2：直接遍历链表，然后在末尾加
// ListNode pre = dummy;//虚拟节点
// ListNode cur = dummy.next;//这个才是真正的“头节点”所在的位置
ListNode cur = dummy;
while(cur.next != null){//遍历结束条件是遇到next为空的节点
cur = cur.next;
}
ListNode node4add = new ListNode(val);
cur.next = node4add;
size++;
}
//在指定位置前插入新的节点
//要求
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
public void addAtIndex(int index, int val) {
//先判定index是否合法
if(index > size){
return;
}else if(index < 0){
index = 0;
}
//有两种写法：使用临时节点变量pre指代dummyhead+cur指代当前节点、直接使用一个cur
// //写法1：
// ListNode pre = dummy;
// ListNode cur = dummy.next;
// //遍历寻找待修改的节点
// // while(index){
// // cur = cur.next;
// // index--;
// // }
// for(int i = 0; i < index; i++){
// pre = cur;
// cur = cur.next;
// }
// //找到了就开始插
// //新建用来插入的节点
// ListNode node4add = new ListNode(val);
// //按步骤插入
// node4add.next = pre.next;
// pre.next = node4add;
// size++;
// //写法2：
ListNode cur = dummy;
//遍历找点
// while(index){
// cur.next = cur.next.next;//cur = cur.next也行，就多遍历一个dummy节点的区别
// index --;
// }
for(int i = 0; i < index; i++){
cur = cur.next;
}
//新建用来插入的节点
ListNode node4add = new ListNode(val);
node4add.next = cur.next;
cur.next = node4add;
size ++;
}
public void deleteAtIndex(int index) {
if(index < 0 || index >= size){
return;
}
size--;
//还是先找到要删除的节点
// ListNode pre = dummy;
// ListNode cur = dummy.next;
ListNode cur = dummy;
// while(index){
// cur = cur.next;
// }
for(int i = 0; i < index; i++){
cur = cur.next;
}
//找到后开始删除
// pre.next = cur.next;
// cur.next = null;
cur.next = cur.next.next;
}
}
【LeetCode链表#7】设计一个链表并实现常见的操作方法的更多相关文章
- 6.5 k个已排好序链表合并为一个排序链表
1 建立链表(带哨兵位的)2 建立最小堆方法3 合并已排好序的k个链表 typedef int DataType; //建立链表 class Link { private: struct Node { ...
- 牛客网：将两个单调递增的链表合并为一个单调递增的链表-Python实现-两种方法讲解
方法一和方法二的执行效率,可以大致的计算时间复杂度加以对比,方法一优于方法二 1. 方法一: 思路: 1. 新创建一个链表节点头,假设这里就叫 head3: 2. 因为另外两个链表都为单调递增,所 ...
- 面试题6：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList
题目 输入一个链表,按链表值从尾到头的顺序返回一个ArrayList. 思路 使用栈依次存放输入的链表顺序的值,然后依次出栈便是链表的逆序. 代码 import java.util.ArrayList ...
- 链表操作----将单链表向右旋转 K 个位置
给定一个单链表,设计一个算法实现链表向右旋转 K 个位置. 举例: 给定 1->2->3->4->5->6->NULL, K=3 则 4->5-> ...
- 设单链表中存放n个字符，试设计一个算法，使用栈推断该字符串是否中心对称
转载请注明出处:http://blog.csdn.net/u012860063 问题:设单链表中存放n个字符.试设计一个算法,使用栈推断该字符串是否中心对称,如xyzzyx即为中心对称字符串. 代码例 ...
- 笔试题&面试题：设计一个复杂度为n的算法找到单向链表倒数第m个元素
设计一个复杂度为n的算法找到单向链表倒数第m个元素.最后一个元素假定是倒数第0个. 提示:双指针查找 相对于双向链表来说,单向链表仅仅能从头到尾依次訪问链表的各个节点,所以假设要找链表的倒数第m个元素 ...
- leetcode菜鸡斗智斗勇系列（1）---把一个链表中的二进制数字转换为一个整型数（int）
Convert Binary Number in a Linked List to Integer这道题在leetcode上面算作是“easy”,然而小生我还是不会做,于是根据大佬的回答来整理一下思路 ...
- 链表习题（1）-设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点
/*设计一个递归算法,删除不带头结点的单链表L中所有值为x的结点*/ /* 算法思想:设f(L,x)的功能是删除以L为首结点指针的单链表中所有值等于x的结点, 则显然有f(L->next,x)的 ...
- [链表]LeetCode 25 K组一个翻转链表
LeetCode 25 k组一个翻转链表 TITLE 示例 1: 输入:head = [1,2,3,4,5], k = 2 输出:[2,1,4,3,5] 示例 2: 输入:head = [1,2,3, ...
- 有一个线性表，采用带头结点的单链表L来存储，设计一个算法将其逆置，且不能建立新节点，只能通过表中已有的节点的重新组合来完成。
有一个线性表,采用带头结点的单链表L来存储,设计一个算法将其逆置,且不能建立新节点,只能通过表中已有的节点的重新组合来完成. 分析:线性表中关于逆序的问题,就是用建立链表的头插法.而本题要求不能建立新 ...
随机推荐
- 使用 inotifywait的方式监控文件夹发生变化后自动执行脚本的方法
0. 先安装inotify 最简单的方法为: yum install epel-release 安装扩展包源 yum install inotify-tools 1. 从网上抄了一下脚本 简单记录一下 ...
- Bash 脚本发送消息到企业微信的办法
1. Study From https://www.cnblogs.com/elvi/p/11444388.html 2. 申请或者使用已经有的企业微信. 首先是获取一下企业id 方法如图: 3. 创 ...
- Spring 应用合并之路（一）：摸石头过河 | 京东云技术团队
公司在推进降本增效,在尝多种手段之后,发现应用太多,每个应用都做跨机房容灾部署,则最少需要 4 台机器(称为容器更合适).那么,将相近应用做一个合并,减少维护项目,提高机器利用率就是一个可选方案. 经 ...
- JS遍历树形数据
树形数据结构遍历某个key值 深度优先遍历(DFS) let tree = [{ id: '1', name: '节点1', children: [{ id: '1-1', name: '节点1-1' ...
- IdentityServer4 系列文章01---密码授权模式
IdentityServer4实现.Net Core API接口权限认证(快速入门) 什么是IdentityServer4 官方解释:IdentityServer4是基于ASP.NET Core实 ...
- Fabric配置块结构解析
本文是区块链浏览器系列的第二篇. 上一篇介绍了交易块中的数据结构,这一篇介绍区块链网络中的配置块数据结构. 这两种区块中数据结构内容的区别主要Payload结构体中的Data域中的内容,接下来将以类图 ...
- Windows堆管理机制 [1] 堆基础
声明:这篇文章在写的时候,是最开始学习这个堆管理机制,所以写得有些重复和琐碎,基于笔记的目的想写得全一些,这篇文章写的时候参考了很多前辈的文章,已在末尾标出,某些未提及到的可以在评论补充 基于分享的目 ...
- 事务提交之后再执行某些操作 → 引发对 TransactionSynchronizationManager 的探究
开心一刻 昨晚,小妹跟我妈聊天 小妹:妈,跟你商量个事,我想换车,资助我点呀 妈:哎呀,你那分扣的攒一堆都够考清华的,还换车资助点,有车开就不错了 小妹:你要是这么逼我,别说哪天我去学人家傍大款啊 妈 ...
- 3.5 Windows驱动开发：应用层与内核层内存映射
在上一篇博文<内核通过PEB得到进程参数>中我们通过使用KeStackAttachProcess附加进程的方式得到了该进程的PEB结构信息,本篇文章同样需要使用进程附加功能,但这次我们将实 ...
- 21.6 Python 构建ARP中间人数据包
ARP中间人攻击(ARP spoofing)是一种利用本地网络的ARP协议漏洞进行欺骗的攻击方式,攻击者会向目标主机发送虚假ARP响应包,使得目标主机的ARP缓存中的IP地址和MAC地址映射关系被篡改 ...