算法跟学Day3【代码随想录】

算法跟学Day3【代码随想录】

• 203.移除链表元素
• 707.设计链表
• 206.反转链表

leetcode 203 移除链表元素

思路

• 使用循环变量逐个遍历删除满足条件结点

细节

• 设置虚拟头结点完成对链表第一个元素的同等操作

代码

/**
 * 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;
            else cur = cur.next;
        }
        return dummy.next;
    }
}

leetcode 707 设计链表

思路

• 链表的基本增删查

细节

• 添加size属性 分左右两侧来减少查询遍历的开销

代码

class MyLinkedList {

    class Node {
        int val;
        Node next;
        Node prev;
        public Node() {}
        public Node(int val) {this.val = val;}
    }

    Node head = new Node();
    Node tail = new Node();
    int size = 0;

    public MyLinkedList() {
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        Node node = getNode(index);
        return node == null ? -1 : node.val;
    }

    public Node getNode(int index) {
        if (index < 0 || index >= size) return null;
        boolean isLeft = index < size >> 1;
        Node cur = isLeft ? head.next : tail.prev;
        index = isLeft ? index : size - index - 1;
        while (cur != head && cur != tail) {
            if (index-- == 0) return cur;
            cur = isLeft ? cur.next : cur.prev;
        }
        return null;
    }
    
    public void addAtHead(int val) {
        Node node = new Node(val);
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
        size++;
    }
    
    public void addAtTail(int val) {
        Node node = new Node(val);
        node.prev = tail.prev;
        node.next = tail;
        tail.prev.next = node;
        tail.prev = node;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        if (index < 0 || index > size) return;
        else if (index == 0) addAtHead(val);
        else if (index == size) addAtTail(val);
        else {
            Node node = new Node(val);
            Node oldNode = getNode(index);
            node.prev = oldNode.prev;
            node.next = oldNode;
            oldNode.prev.next = node;
            oldNode.prev = node;
            size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        Node node = getNode(index);
        if (node == null) return;
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }
}

/**
 * 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);
 */

leetcode 206 反转链表

思路

• 双指针法

细节

• 注意在写递推关系的时候随时想逻辑 严密的逻辑才会有正确的解

代码

/**
 * 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 p = null, q = head, tmp;
        while (q != null) {
            tmp = q.next;
            q.next = p;
            p = q;
            q = tmp;
        }
        return p;
    }
}