自学Java之LinkedList（三）

继续LinkedList专题，今天的题还是easy的，但明显没那么顺利了

• 203. Remove Linked List Elements 

删除链表元素，其实算很简单的逻辑，但是因为不太熟练会小小地卡住w

fakeHead的用法也想到了，但是忘记去声明一个prev=fakeHead

public class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode fakeHead = new ListNode(-1);/
        fakeHead.next = head;
        ListNode curr = head, prev = fakeHead;
        while (curr != null) {
            if (curr.val == val) {
                prev.next = curr.next;
            } else {
                prev = prev.next;
            }
            curr = curr.next;
        }
        return fakeHead.next;
    }
}

• 160. Intersection of Two Linked Lists

思路：

最初的想法是，考虑到链表的特性，用之前的倒转链表函数求出给定的两个链表的倒转，再从头一起遍历。但笔者心有余而力不足，出现了一些奇怪的bug，加之这种方法会改变原有的链表结构，决定先放弃这种想法。

解答中推荐的想法：利用给定的链表，分别按AB和BA拼接成两个新的链表，进行遍历。这样，若两个链表等长，算法便可在一次遍历后完成；否则，也会在两次遍历后结束。

附很妙的解答：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null|headB==null)
            return null;
        ListNode tmpa=headA;
        ListNode tmpb=headB;
        while(tmpa!=tmpb){
            tmpa=(tmpa==null)?headB:tmpa.next;
            tmpb=(tmpb==null)?headA:tmpb.next;
        }
        return tmpa;
    }
}

• 234. Palindrome Linked List

思路：

单纯的想法是，求出倒转链表，同时、逐个遍历。但是笔者尝试倒转链表，只得到原链表的最后一个元素..

先贴上有bug的源代码

class Solution {
    private ListNode reverseList(ListNode head) {       
        ListNode prev = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = prev; 
            prev = head;
            head = next;
        }
        return prev;
    }
    
    public boolean isPalindrome(ListNode head) {
        ListNode cur=head;         
        if(cur==null||cur.next==null)
            return true;
		// 翻转链表
        ListNode rev=reverseList(cur);
        while(cur!=null&&cur.val==rev.val){
            cur=cur.next;
            rev=rev.next;        
        }
        if(cur!=null)
            return false;
        return true;
    }
}

大众的想法是，先用快慢指针找到中点，再对后半链表求倒转，比较两半链表。

其实两种想法本质上相同，笔者在检查后发现是倒转的操作改变了原链表，使给定的head链表只剩下第一个元素。

尝试后发现这类想法（貌似）都会改变输入的结构，所以折半倒转的方法才是既改变了原输入又能得到结果的简单方法！

附上笔者终于接受现实后改进的代码

class Solution {
    private ListNode reverseList(ListNode head) {       
        ListNode prev = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = prev; 
            prev = head;
            head = next;
        }
        return prev;
    }
    
    public boolean isPalindrome(ListNode head) {
        ListNode slow=head;
        ListNode fast=head;         
        if(slow==null||slow.next==null)
            return true;
        //找中点
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        // 翻转链表
        slow=reverseList(slow);//后半链表
        
        fast=head;//用fast单纯为减少空间开销
        while(slow!=null&&fast.val==slow.val){
            fast=fast.next;
            slow=slow.next;        
        }
        return slow==null;
    }
}

啰嗦一下，这种方法不仅简单直观，相比大佬们复杂的递归法还是相当多快好省↓

以上就是LinkedList专题里的最后三道easy，刷一刷还是很快的嘛，后面也继续坚持下去吧~~