剑指offer_24and近期练习题（链表章）

剑指 Offer 24. 反转链表

感觉大多数的链表，栈，队列，树等问题，好像都有一种递归的解法，不仅简洁，而且还通俗易懂。但是一般我想不到，隐隐约约感觉可以递归，就是无从下手。

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = reverseList(head.next);
        head.next.next = head; //先递归到head.next为5，然后再回溯。
//让(4.next)(就是5).next指向4,然后依次往前。
        head.next = null;//防止回环
        return newHead;//newhead还是链表最后一个head，直接返回即可
    }
}

正常第一想到的就是双指针来遍历了。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;  //慢指针
        ListNode cur = head;  //快指针
        while(cur!=null){
            ListNode next = cur.next;  //新节点存放cur.next的值
            cur.next = pre;  //cur的下一节点指向pre
            pre = cur;     
            cur = next; 
        }
        return pre;
    }
}

141. 环形链表

判断链表有无闭环，其实就类似数组中有无重复数，所以第一个思路就是用哈希表来遍历来找重复元素。

public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> set = new HashSet<ListNode>();
//最重要的当然还是set.add()的返回值问题，当哈希表中无当前元素，添加返回1，如果有当前元素，返回0
//如果！set.add(head)为1，那么就是一个head遍历了两遍，说明闭环，返回真。
        while(head!=null){
            if(!set.add(head)){
                return true;
            }
            head=head.next;
        }
        return false;
    }
}

第二个就是快慢指针了

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null){
            return false;
        }
        ListNode slow = head;  //初始fast在slow前一个？
//
        ListNode fast = head.next;
        while(fast!=null&&fast.next!=null){ //slow一次走一个
            if(slow==fast){                  //fast一次走两个
                return true;                 //如果闭环必定相遇
            }
            slow = slow.next; 
            fast = fast.next.next;
            
        }
        return false;
    }
}

203. 移除链表元素

首先，肯定是有个递归的方法，然后我还是没有想到，甚至在整理的时候，也是把这个遗漏了。有时候递归很好理解，有时候又看不懂或者需要思考好久好久，这倒是让我学会了断点去理解。

class Solution {
    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;//从后往前回溯
    }
}

第二种就是迭代，我看到题解有两种，一种初始化虚拟头结点的，另一种不初始化的，其实感觉都差不多，就是遇到当前结点的下一结点的元素和指定元素相同时，，当前结点指向下一节点的下一节点。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
            ListNode dummyHead = new ListNode(0); //初始化虚拟头结点
            dummyHead.next = head;//dum的下一节点指向head
            ListNode temp = dummyHead;//temp表示当前结点
                                        //这样可以防止头结点和val相等被直接删除的情况
            while(temp.next != null){
                if(temp.next.val == val){
                    temp.next=temp.next.next; //核心
                }else{
                temp=temp.next;
                }
            }
            return dummyHead.next;
    }
}

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //删除值相同的头结点后，可能新的头结点也值相等，用循环解决
        while(head!=null&&head.val==val){
            head=head.next;
        }
        if(head==null)
            return head;
        ListNode prev=head;
        //确保当前结点后还有结点
        while(prev.next!=null){
            if(prev.next.val==val){
                prev.next=prev.next.next;
            }else{
                prev=prev.next;
            }
        }
        return head;
    }
}

83. 删除排序链表中的重复元素

这一题首先想到的确实不是递归了，但是做着做着，知道他确实可以递归！

删除元素之类的，感觉指针是优先的了

单指针，双指针也都是可以做的。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return head;
        }
        ListNode cur = head;
        while(cur.next != null){
            if(cur.val==cur.next.val){  //比较当前结点和下一结点的值，
                cur.next=cur.next.next;//相同就使cur的下一结点指向下下结点
            }else{
                cur=cur.next;
            }
        }
        return head;
    }
}

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return head;
        }
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur!= null){
            if(pre.val == cur.val){
                pre.next=cur.next;
                cur = cur.next;
            }else{
                pre = pre.next;
                cur=cur.next;
            }
        }
        return head;
    }
}

接着就是<最喜欢>的递归了，递归真的是少而精！其实有时候还是不大理解的，就比如先是head.next,下面又变成了head，感觉饶了一圈。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (null == head || null == head.next) {
            return head;
        }

        head.next = deleteDuplicates(head.next);
        return head.val == head.next.val ? head.next : head;
    }
}

还有初始化虚拟头结点的方法，就是为了规避头结点空或者只有一个之类的情况，感觉就是单指针的升级版。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummyHead = new ListNode(1000, head);
        ListNode cur = dummyHead;  
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return dummyHead.next;
    }
}

最没有想到的，是他用了栈，我也试着自己打了一遍，发现了其时间复杂度变高了，但是那个出栈时放置下一结点的思想确实不错。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return head;
        }
        Stack<ListNode> deque = new Stack<ListNode>();
        while(head.next!=null){
            if(head.val!=head.next.val){
                deque.push(head);
            }
            head = head.next;
        }
        while(!deque.isEmpty()){
            deque.peek().next = head;
            head = deque.pop();
        }
        return head;
    }
}

基本的链表题目前就刷了这一点，这几天还涉及了字符串的几个题和栈，二叉树，接着继续回味！