day03:203.移除链表元素、707.设计链表、206.反转链表
LeetCode 203.移除链表元素
题目链接:
文章讲解:
https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html
视频讲解:
https://www.bilibili.com/video/BV18B4y1s7R9/
思路和解法:
原链表删除元素
1、首先判断头结点不为空,防止出现操作空指针的情况,同时头结点的值是我们要删的值,则head = head.next,且还要注意的是,这是一个持续的步骤,因为第二个、第三个等等都可能是我们要删的值
2、创建一个临时节点cur指向头结点,即cur = head,依次遍历链表,循环条件是cur != null && cur.next != null
cur != null是为了防止操作空节点而报错
cur.next != null是因为我们要取cur.next的值和要删除的值val对比,如果cur.next是空的话,那又会出现操作空指针的情况
3、如果cur.next指向的值等于val,则将cur.next指向cur.next.next,若不等于,则cur接着往下走,即cur=cur.next。
4、最后return head,因为对链表进行操作的时候,是定义了一个临时节点cur进行遍历的,head还是指向一开始操作的这个链表
public class Solution {
public ListNode RemoveElements(ListNode head, int val) {
while(head != null && head.val == val)
{
head = head.next;
}
ListNode cur = head;
while(cur != null && cur.next != null)
{
if(cur.next.val == val)
cur.next = cur.next.next;
else
cur = cur.next;
}
return head;
}
}
使用虚拟头节点
1、定义一个虚拟头结点dummyHead,将dummyHead的下一个节点指向头结点。这样可以以一个统一的个规则来对链表进行删除操作,也就是说省掉了 原链表删除元素方法 中对头结点特殊情况的处理。
2、定义一个临时的指针cur等于dummyHead。
定义临时指针cur指向头结点head来遍历而不直接用头结点head遍历是因为如果用head来遍历,则head指向的值是不断变化的,最后无法返回原链表的头结点。
cur等于dummyHead是因为我们要删的其实是cur.next,那么就必须要知道cur.next的上一个指针是什么,也就是cur,只有删的是cur.next,才能让cur直接指向cur.next.next
3、遍历链表,循环条件是cur.next != null,如果cur.next指向的值等于val,则将cur.next指向cur.next.next,若不等于,则cur接着往下走,即cur=cur.next。
4、最后return dummyHead.next,不return head是因为head有可能被删了,只有dummyHead.next才是新链表里的头结点
public class Solution {
public ListNode RemoveElements(ListNode head, int val) {
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode cur = dummyHead;
while(cur.next != null)
{
if(cur.next.val == val)
cur.next = cur.next.next;
else
cur = cur.next;
}
return dummyHead.next;
}
}
LeetCode 707.设计链表
题目链接:
文章讲解:
https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html
视频讲解:
https://www.bilibili.com/video/BV1FU4y1X7WD/
思路和解法:
单链表
class ListNode{
public int val;
public ListNode next;
public ListNode(int val)
{
this.val = val;
}
}
public class MyLinkedList {
//size存储链表元素的个数
int size;
//虚拟头结点
ListNode head;
//初始化链表
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
//获取第index个节点的数值,注意index是从0开始的,第0个节点就是头结点
public int Get(int index) {
//如果index非法,返回-1
if(index < 0 || index >= size)
return -1;
ListNode cur = head;
//包含一个虚拟头节点,所以查找第 index+1 个节点
for(int i = 0; i <= index; i++)
{
cur = cur.next;
}
return cur.val;
}
//在链表最前面插入一个节点,等价于在第0个元素前添加
public void AddAtHead(int val) {
AddAtIndex(0, val);
}
//在链表的最后插入一个节点,等价于在(末尾+1)个元素前添加
public void AddAtTail(int val) {
AddAtIndex(size, val);
}
// 在第 index 个节点之前插入一个新节点,例如index为0,那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度,则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度,则返回空
public void AddAtIndex(int index, int val) {
if(index > size)
{
return;
}
if(index < 0)
{
index = 0;
}
size++;
//找到要插入节点的前驱
ListNode pred = head;
for(int i = 0; i< index; i++)
{
pred = pred.next;
}
ListNode toAdd = new ListNode(val);
toAdd.next = pred.next;
pred.next = toAdd;
}
//删除第index个节点
public void DeleteAtIndex(int index) {
if(index < 0 || index >= size)
{
return;
}
size--;
ListNode pred = head;
for(int i = 0; i < index; i++)
{
pred = pred.next;
}
pred.next = pred.next.next;
}
}
双链表
class ListNode{
public int val;
public ListNode next,prev;
public ListNode(int val){
this.val = val;
}
}
class MyLinkedList {
//记录链表中元素的数量
int size;
//记录链表的虚拟头结点和尾结点
ListNode head,tail;
public MyLinkedList() {
//初始化操作
this.size = 0;
this.head = new ListNode(0);
this.tail = new ListNode(0);
//这一步非常关键,否则在加入头结点的操作中会出现null.next的错误!!!
head.next=tail;
tail.prev=head;
}
public int Get(int index) {
//判断index是否有效
if(index<0 || index>=size){
return -1;
}
ListNode cur = this.head;
//判断是哪一边遍历时间更短
if(index >= size / 2){
//tail开始
cur = tail;
for(int i=0; i< size-index; i++){
cur = cur.prev;
}
}else{
for(int i=0; i<= index; i++){
cur = cur.next;
}
}
return cur.val;
}
public void AddAtHead(int val) {
//等价于在第0个元素前添加
AddAtIndex(0,val);
}
public void AddAtTail(int val) {
//等价于在最后一个元素(null)前添加
AddAtIndex(size,val);
}
public void AddAtIndex(int index, int val) {
//index大于链表长度
if(index>size){
return;
}
//index小于0
if(index<0){
index = 0;
}
size++;
//找到前驱
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
//新建结点
ListNode newNode = new ListNode(val);
newNode.next = pre.next;
pre.next.prev = newNode;
newNode.prev = pre;
pre.next = newNode;
}
public void DeleteAtIndex(int index) {
//判断索引是否有效
if(index<0 || index>=size){
return;
}
//删除操作
size--;
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
pre.next.next.prev = pre;
pre.next = pre.next.next;
}
}
LeetCode 206.反转链表
题目链接:
文章讲解:
https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html
视频讲解:
https://www.bilibili.com/video/BV1nB4y1i7eL/
思路和解法:
迭代(双指针):
遍历链表,在访问各个节点是修改next引用指向。
- 定义一个cur指针,指向头节点,再定义一个pre指针,初始化为null
- 开始反转,用tmp节点保存cur.next节点。
- 改变cur.next的指向,指向pre节点,此时已经反转了第一个节点。
- 接着移动pre和cur指针,直至cur指向null,循环结束,返回pre节点
public class Solution {
public ListNode ReverseList(ListNode head) {
ListNode cur = head;
ListNode pre = null;
while(cur != null)
{
ListNode tmp = cur.next; //暂存后继节点
cur.next = pre;//修改next引用指向
pre = cur;//pre暂存cur
cur = tmp;//cur访问下一节点
}
return pre;
}
}