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

于 2024-05-10 22:43:01 发布
阅读量311 收藏 5
点赞数 4
文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76229594/article/details/138683891
版权

203.移除链表元素

移除指定值的结点

特别方法：虚拟头结点可以让头结点和其他位置的结点一并操作。例如此时头结点是目标值，可以按照一般操作即可，不需特别讨论。

当cur.next存放的是目标值时，不用更新cur 的值，因为此时cur.next是新的值，还没有进行判断。

注意最后返回的是dummy.next 避免头结点可能被删除的可能。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 设置虚拟头结点，统一删除方式
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode cur = dummy;
        while (cur.next!= null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
                //cur = cur.next;这里不用往后移动
            } else {
                cur = cur.next;
            }
        }
        return dummy.next;//第一个节点被删除了，head也没了
    }
}

707.设计链表

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点

获取指定位置的值

注意链表的下标和数组一样，都是从0开始的。

public int get(int index) {
        //越界或异常判断,链表下标从0开始
        if(index>=size||index<0){
            return -1;
        }
        ListNode cur=head;
        //包含一个头结点，找到第index+1个结点的位置
        for(int i=0;i<=index;i++){
            cur=cur.next;
        }
        return cur.val;
    }

增删节点

增删结点的核心在于找到目标位置的前一个位置，因为插入和删除都需要前一个结点操作，所以for循环中找的是目标位置的前一个位置。

插入的时候注意顺序，插入先让l指向cur.next.next，然后再让cur.next指向l，顺序不能颠倒。

增删列表注意size的变化。

 public void addAtIndex(int index, int val) {
        //注意插入和删除都需要找到该结点的前一个位置
        if(index>size||index<0){
            return;
        }
        
        ListNode cur=head;
        ListNode l=new ListNode(val);
        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        l.next=cur.next;
        cur.next=l;
        size++;//别忘了+1
        
    }
    
    public void deleteAtIndex(int index) {
         if(index>=size||index<0){
            return;
        }
        
        ListNode cur=head;
        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        cur.next=cur.next.next;
        size--;//别忘了长度-1
    }
}

完整代码

class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

class MyLinkedList {
    //单链表
    int size;
    ListNode head;//虚拟头结点,虚拟结点size=1
    public MyLinkedList() {
       size=0;
       head=new ListNode(0);
        
    }
  
    
    public int get(int index) {
        //越界或异常判断,链表下标从0开始
        if(index>=size||index<0){
            return -1;
        }
        ListNode cur=head;
        //包含一个头结点，找到第index+1个结点的位置
        for(int i=0;i<=index;i++){
            cur=cur.next;
        }
        return cur.val;

    }
    
    public void addAtHead(int val) {
        // addAtIndex(0, val);
          ListNode l=new ListNode(val);
          l.next=head.next;
          head.next=l;
          size++;
    }
    
    public void addAtTail(int val) {
        // addAtIndex(size, val);
        ListNode l=new ListNode(val);
        ListNode cur=head;
        while(cur.next!=null){
            cur=cur.next;
        }
       cur.next=l;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        //注意插入和删除都需要找到该结点的前一个位置
        if(index>size||index<0){
            return;
        }
        
        ListNode cur=head;
        ListNode l=new ListNode(val);
        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        l.next=cur.next;
        cur.next=l;
        size++;//别忘了+1
        
    }
    
    public void deleteAtIndex(int index) {
         if(index>=size||index<0){
            return;
        }
        
        ListNode cur=head;
        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        cur.next=cur.next.next;
        size--;//别忘了长度-1
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

206.反转链表（O(n)）

1.双指针

两个指针pre和cur,注意temp最开始的值为null。临时指针temp用来保存cur的下一个结点位置。循环的条件是到了最后cur的值为null。

注意pre=cur，然后cur=temp,顺序不可以颠倒。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //双指针法
        ListNode pre=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode temp=cur.next;
            cur.next=pre;
            pre=cur;//注意二者的顺序
            cur=temp;
        }
        return pre;//返回头结点是pre
    }
}

2.递归算法

时间和空间复杂度都是O(n)

递归算法就是找相似，总是让后一个指针指向前一个指针，不断更新传入的参数，就是将pre和cur向后移动一位，到最后传入的反转的位置为null时，即到达了最后，返回pre头结点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        // 双指针法
        ListNode pre = null;
        ListNode cur = head;
        return reverseList(head, pre, cur);
    }

    public ListNode reverseList(ListNode head, ListNode pre, ListNode cur) {
        if (cur == null) {//最后的条件
           return pre;
        }
        ListNode temp=cur.next;
        cur.next=pre;
        return reverseList(head, cur, temp);
    }
}
特斯拉plus
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值