算法学习 day3

时间：2025-02-08 19:42:54

文章目录

      • **[203. 移除链表元素]/)**
        • 思路
        • 复杂度
        • [707. 设计链表]()
        • 思考
        • 复杂度
      • **[206. 反转链表]()**
        • 思考
        • 复杂度

[203. 移除链表元素]/)

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 == val 的节点，并返回 新的头节点 。

思路
  • 删除满足条件的val，可以理解为删除指定节点，需要知道前一个节点pre， = 即可删除指定节点
  • 虚节点试用，如果不试用虚节点，需要对链表为null增加逻辑判断，虚节点刚好避免了次判断，在最后返回虚节点.next即可
复杂度
  • 时间 O(n)
  • 空间 O(1)
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) {  = val; }
 *     ListNode(int val, ListNode next) {  = val;  = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null ) return head;
        ListNode dummy = new ListNode();
        ListNode pre = dummy ,cur = head ;
        pre.next = cur ;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next ;
            }else{
                pre = cur ; 
            }
            cur = cur.next;
        } 
        return dummy.next;

    }
}
707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。

思考
  • 涉及链表节点删除，即可想到试用虚节点
  • 通过索引获取链表，则需要记录节点数量，对非法索引校验
复杂度
  • 时间 O(n) （n为索引操作的值）
  • 空间 O(1)
class MyLinkedList {
    private ListNode dummy = new ListNode();
    private int cnt;

    public MyLinkedList() {

    }

    public int get(int index) {
        if (index < 0 || index >= cnt) {
            return -1;
        }
        var cur = dummy.next;
        while (index-- > 0) {
            cur = cur.next;
        }
        return cur.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    public void addAtTail(int val) {
        addAtIndex(cnt, val);
    }

    public void addAtIndex(int index, int val) {
        if (index > cnt) {
            return;
        }
        var pre = dummy;
        while (index-- > 0) {
            pre = pre.next;
        }
        pre.next = new ListNode(val, pre.next);
        ++cnt;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= cnt) {
            return;
        }
        var pre = dummy;
        while (index-- > 0) {
            pre = pre.next;
        }
        var t = pre.next;
        pre.next = t.next;
        --cnt;
    }
}

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

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思考
  • 翻转链表需要到三个索引pre、cur、next，避免断链，next要在指向改变前获取
  • 翻转过程中，同一时刻右两个链表，pre代表新链表，cur代表当前链表；
  • pre初始化必须为null，因为翻转后的第一个节点是最后一个节点，必须指向null
复杂度
  • 时间 O(n) （n为索引操作的值）
  • 空间 O(1)
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) {  = val; }
 *     ListNode(int val, ListNode next) {  = val;  = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null) return head;
        ListNode pre = null ,cur = head;
        while(cur != null){
            ListNode next = cur.next ;
            cur.next = pre ; 
            pre = cur ; 
            cur = next ; 
        }
        return pre ; 
    }
}

相关文章