【刷题day3】链表| 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;
    }
}

203.移除链表元素

题目链接/文章讲解

思路： 删除节点步骤：

• 找到该结点的前一个结点
• 进行删除操作。

注意若没有虚拟头节点，则需要对移除头节点的情况单独考虑。

1. 迭代法：创建两个指针，cur指向当前结点，pre指向前一个结点 ，协同向后遍历。

2. 递归：设置递归出口后，考虑对除了头节点 head 以外的节点已经进行了递归删除操作，然后只需判断 head 的节点值是否等于给定的 val。如果等于 val，则删除 head 后的头节点置为 head.next；如果不等于 val，则 head 保留，因此删除操作后的头节点还是 head。

class Solution {//时间复杂度：O(n),空间复杂度：O(1)
	public ListNode removeElements(ListNode head, int val) {
		if(head == null) return head;
		ListNode L = new ListNode(-1, head);//虚拟头节点，保证操作的一致性。避免移除头结点和其他节点的操作不一样
		ListNode pre = L, cur = head;
		while(cur != null) {
			if(cur.val == val) {
				pre.next = cur.next;
			}else {
				pre = cur;
			}
			cur = cur.next;
		}
		return L.next;
	} 
}

//递归法
class Solution {//时间复杂度：O(n),空间复杂度：O(n)
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }
}

707.设计链表

题目链接/文章讲解

思路： 熟悉链表操作，注意设置虚拟头节点，方便处理操作。

class MyLinkedList {
    int size;
	ListNode head; //虚拟头节点
	public MyLinkedList() {
		size = 0;
		head = new ListNode(0);
    }
    
    public int get(int index) {
    	if(index > size-1 || index < 0) return -1;
    	ListNode cur = head;
    	for(int i = 0; i <= index; i++) { //由于cur开始指向的是虚拟头节点，所以多遍历一次
    		cur = cur.next;
    	}
    	return cur.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;
    	ListNode cur = head;
    	for(int i = 0; i < index; i++) {//定位至index前一个结点
    		cur = cur.next;
    	}
    	ListNode addNode = new ListNode(val);
    	addNode.next = cur.next;
    	cur.next = addNode;
    	size++;
    }
    
    public void deleteAtIndex(int index) {
    	if(index < 0 || index > size-1) {
    		return;
    	}
    	ListNode cur = head;
    	for(int i = 0; i < index; i++) {
    		cur = cur.next;
    	}
    	cur.next = cur.next.next ;
    	size--;
    }
}

206.反转链表

题目链接/文章讲解

思路： 如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。
其实只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表。

注意还需要一个临时结点temp，用来保存cur反转前指向的下一个结点，避免断链。

class Solution {
    public ListNode reverseList(ListNode head) {
    	if(head == null) return head;
    	ListNode cur = head, pre = null;
    	ListNode temp = null; //保存cur反转前指向的下一个结点，避免断链
    	while(cur != null) {
    		temp = cur.next; //首先将下一个反转节点做好备份
    		cur.next = pre; //反转
    		pre = cur; //更新下次反转应指向的结点
    		cur = temp; //更新下次反转结点
    	}
    	return pre;
    }
}

递归法：从后向前递归。递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分已经被反转，考虑现在应该如何反转它前面的部分

    /**
     * 以链表1->2->3->4->5举例
     * @param head
     * @return
     */
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            /*
                直到当前节点的下一个节点为空时返回当前节点
                由于5没有下一个节点了，所以此处返回节点5
             */
            return head;
        }
        //递归传入下一个节点，目的是为了到达最后一个节点
        ListNode newHead = reverseList(head.next);
                /*
            第一轮出栈，head为5，head.next为空，返回5
            第二轮出栈，head为4，head.next为5，执行head.next.next=head也就是5.next=4，
                      把当前节点的子节点的子节点指向当前节点
                      此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4.next=null
                      此时链表为1->2->3->4<-5
                      返回节点5
            第三轮出栈，head为3，head.next为4，执行head.next.next=head也就是4.next=3，
                      此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3.next=null
                      此时链表为1->2->3<-4<-5
                      返回节点5
            第四轮出栈，head为2，head.next为3，执行head.next.next=head也就是3.next=2，
                      此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
                      此时链表为1->2<-3<-4<-5
                      返回节点5
            第五轮出栈，head为1，head.next为2，执行head.next.next=head也就是2.next=1，
                      此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1.next=null
                      此时链表为1<-2<-3<-4<-5
                      返回节点5
            出栈完成，最终头节点5->4->3->2->1
         */
        head.next.next = head;
        head.next = null;
        return newHead;
    }