链表必刷题之二

1.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。

public ListNode partition(ListNode pHead, int x) {
        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;
        ListNode cur = pHead;
        while(cur!=null){
            if(cur.val < x){
                //尾插法
                if(bs == null){
                    bs = cur;
                    be = cur;
                }else{
                    be.next = cur;
                    be = be.next;
                }
            }else{
                if(as == null){
                    as = cur;
                    ae = cur;
                }else{
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        if(bs == null) {
            return as;
        }
        be.next = as;
        //如果后面区段有数据,需要把最后一个节点的next置为空,否则会出现死循环
        if(as != null) {
            ae.next = null;
        }
        return bs;
    }

图解：将链表分成两个链表，bs到be的链表是数据小的链表，as到ae的链表是数据大的链表，最后将两个链表连接。

2.链表的回文结构。

public boolean chkPalindrome(ListNode A) {
         if(A==null||A.next==null){
            return true;
        }
        //1.求中间节点
        ListNode fast = A;
        ListNode slow = A;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        //2.逆置右边节点
        ListNode cur = slow.next;
        while(cur!=null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //3.判断回文
        ListNode left = A;
        ListNode right = slow;
        while(left!=right){
            if(left.val!=right.val){
                return false;
            }else{
                left = left.next;
                right = right.next;
            }
            //偶数链表结束条件
            if(left.next==right) {
                return true;
            }
        }
        return true;
    }

图解：

 

3.输入两个链表，找出它们的第一个公共结点。

public int size(ListNode head) {
        ListNode cur = head;
        int num = 0;
        while(cur!=null){
            num++;
            cur = cur.next;
        }
        return num;
    }
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null){
            return null;
        }
        //1.求两个链表的长度
        ListNode pl = headA;
        ListNode ps = headB;
        int lenA = size(headA);
        int lenB = size(headB);
        int len = lenA-lenB;
        if(len<0){
            pl = headB;
            ps = headA;
            len = lenB -lenA;
        }
        //2.让长链表先走长度差,在一起走直到遇到公共节点
        while(len!=0){
            pl = pl.next;
            len--;
        }
        while(pl!=ps){
            pl = pl.next;
            ps = ps.next;
        }
        if(pl == null&&ps == null){
            return null;
        }
        return pl;
    }

 图解：两个链表的长度差就是公共节点以前的长度差，让快指针先走长度差的步数，然后快慢指针一起走直到相遇就找到了公共节点，如果指针为空则说明没有相遇即没有公共节点。

4.给定一个链表，判断链表中是否有环。 

public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
             if(fast==slow) {
                return true;
            }
        }
        return false;
    }

图解：

5.给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL

public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow) {
                break;
            }
        }
        if(fast==null||fast.next==null) {
            return null;
        }
        //双指针一次走一步情况下,路程关系为head到公共节点的路程==相遇点到公共节点的路程+环的长度的n-1倍
        fast = head;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }

图解：利用上题的思路找到快慢指针在环中的相遇点，然后通过数学公式推导可以发现从head出发的指针与从相遇点出发的指针会同时到达入口点（环中的指针可能走过多圈）。