代码随想录算法训练营第三天 | 链表-203.移除链表元素、707.设计链表、206.反转链表

已于 2023-08-29 15:49:45 修改
阅读量98 收藏
点赞数
文章标签： 算法 链表 数据结构
于 2023-08-27 21:55:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43173942/article/details/132528446
版权

day03：203.移除链表元素、707.设计链表、206.反转链表

LeetCode 203.移除链表元素

题目链接：

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.设计链表

题目链接：

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.反转链表

题目链接：

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;
    }
}
_Cyhui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值