Leetcode-day03-链表

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

思路：因为删除头节点元素的操作和删除后续元素的操作不一样，所以可以增加一个dummy节点。

初始化dummy指向head，pre指向dummy，node指向head（防止head丢失，其实可做可不做，因为这里有dummy）。让pre始终指向当前寻找节点的前一个。如果该元素不是当前要删除的节点，让pre和node往后走，如果要删，per.next=node.next; node = pre.next;

    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1,head);//因为列表元素范围[1,50]，设置-1避免重复
        ListNode node = head;
        ListNode pre = dummy;
        //移除节点只需要让该节点的行一个指向该节点的下一个，因为是单链表，所以要记录该节点的上一个节点
        while(node!=null){
            if(node.val == val){
                pre.next = node.next;//移除元素
                node = pre.next;//node更新
                continue;
            }
            pre = pre.next;//如果不是删除该元素，pre，node往后走
            node = node.next;
        }
        return dummy.next;
    }

设计链表. - 力扣（LeetCode）

关键是while，或者for循环边界怎么确定，带入特殊值看看，就看如果是在头结点上操作。

class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
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 currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.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--;
        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）

思路：单向链表，要让当前节点的next指向前一个节点，所以需要记录前一个节点pre，另外，如果更新了当前节点的next，则找不到原链表的下一个节点了，所以得有nxt记录原链表的下一个节点。最后是cur指向了null,pre指向了原链表的最后一个节点，也就是反转后的head

    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head; 
        ListNode nxt;
        while(cur!=null){
            nxt = cur.next;
            cur.next=pre;
            pre = cur;
            cur = nxt;
        }
        return pre;

    }