算法修炼Day03|链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

链表理论基础

//链表定义
public class ListNode {
    // 节点的值
    int val;
    
    // 下一个节点
    ListNode next;
    
    // 节点的构造函数（无参）
    public ListNode() {

    }
    
    // 节点的构造函数（有一个参数）
    public ListNode(int val) {
        this.val = val;
    }
    
    // 节点的构造函数（有两个参数）
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

LeetCode：203.移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

1.思路

设置虚拟头节点，可以对整个链表做移除操作，返回虚拟头节点的下一个节点即可。

2.代码实现

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(-1, head);
        ListNode cur = dummyHead.next;
        ListNode pre = dummyHead;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return dummyHead.next;
    }
}

3.复杂度分析

时间复杂度：O(n).

空间复杂度：O(1).

LeetCode：707.设计链表 

707. 设计链表 - 力扣（LeetCode）

1.思路

增删查

2.代码实现

// 单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    }
}

class MyLinkedList {
    int size;
    ListNode head;

    public MyLinkedList() { 
        size = 0;
        head = new ListNode(0);
    }
    
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    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;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
            return;
        }
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

LeetCode：206.反转链表

206. 反转链表 - 力扣（LeetCode）

1.思路

虚拟头节点、临时节点、当前节点，很容易迷

2.代码实现

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}

3.复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)