算法Day3 | Leetcode203.移除链表元素、707.设计链表、206.反转链接

203.移除链表元素

提示：这里可以添加技术概要

力扣链接

思路

跟数组的双指针很像，Day1写的原地移动数组跟这个是一样的，只是这个是链表而已。这里多引入一个虚拟头节点，方便处理头节点也是待删除元素。注意的是如果删除了节点，那指针就不该动了，不然删除尾节点会出现问题。

代码

/**
 * 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) {
        if(head==null) return head;
        ListNode p=new ListNode(-1);
        ListNode pre=p;
        ListNode cur=head;
        pre.next=cur;
        while(cur!=null){
            if(cur.val==val){
                pre.next=cur.next;
            }else{
                pre=cur;
            }
            cur=cur.next;
        }
        return p.next;
    }
}

链表的结构力扣有给，但是笔试一般不给

707.设计链表

力扣链接

思路

需要注意index有没有越界，需要自定义链表结构。处理好边界值就行

代码

class ListNode{
    int val;
    ListNode next;
    public ListNode(int val){
        this.val=val;
    }
    public ListNode(){}
}
class MyLinkedList {
    ListNode head;
    int size;

    public MyLinkedList() {
        head=new ListNode(0);
        size=0;
    }

    public int get(int index) {
        if(index>=size||index<0){
            return -1;
        }
        ListNode p=new ListNode();
        p=head.next;
        int count=0;
        while(count<index){
            p=p.next;
            count++;
        }
        return p.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;
        }
        size++;
        ListNode newnode=new ListNode(val);
        ListNode p=head;
        int count=0;
        while(count<index){
            p=p.next;
            count++;
        }
        newnode.next=p.next;
        p.next=newnode;
    }
    
    public void deleteAtIndex(int index) {
        if(index>=size || index<0){
            return;
        }
        size--;
        ListNode p=head;
        int count=0;
        while(count<index){
            p=p.next;
            count++;
        }
        p.next=p.next.next;
    }
}

/**
 * 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.反转链接

力扣链接

思路

一般操作链表考虑用递归或者双指针。如果是递归的话，这里需要注意的是递归的返回条件（倒数第二个节点返回）以及如果遇到空链表（直接返回），所以返回条件有二。要想清楚操作的链表，以及返回的节点（尾节点反转后就是头节点了，所以返回要保留住该节点）。

代码

双指针

/**
 * 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;
        ListNode temp=null;
        while(cur!=null){
            temp=cur;
            cur=cur.next;
            temp.next=pre;
            pre=temp;
        }
        return 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) {
        if(head==null||head.next==null) return head;    //head==null是防止给了个空链表，不是递归到空，递归是next为空
        ListNode tail=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return tail;
    }
}