链表面试练习习题（Java）

1.

思路：

创建两个链表，一个用来记录小于x的结点，一个用来记录大于等于x的结点，然后遍历完原链表后，将小于x的链表和大于等于x的链表进行拼接即可

public class Partition {  
    public ListNode partition(ListNode pHead, int x) {  
        if (pHead == null || pHead.next == null) {  //如果链表为空或者只有一个结点
            return pHead;  
        }  
  
        ListNode beforeHead = new ListNode(0); // 哑节点，用于小于x的链表  
        ListNode before = beforeHead;  
        ListNode afterHead = new ListNode(0); // 哑节点，用于大于等于x的链表  
        ListNode after = afterHead;  
  
        while (pHead != null) {  
            if (pHead.val < x) {  
                before.next = pHead;  
                before = before.next;  
            } else {  
                after.next = pHead;  
                after = after.next;  
            }  
            pHead = pHead.next;  
        }  
  
        // 断开大于等于x的链表的尾部  
        after.next = null;  
        // 将小于x的链表连接到大于等于x的链表之前  
        before.next = afterHead.next;  
  
        return beforeHead.next;  
    }  
}

2.

思路：

首先要判断回文，必须要先找到中间结点，然后以中间结点为分界线，进行左右两部分判断，所以可以采用快慢指针找中间结点

因为是单向链表，右边这一部分很难从后往前走判断是否回文，所以我们要解决这个问题，可以想到的办法就是反转链表，将后面的结点的next指向它的前一个结点，相当于将中间结点后面的单向链表变成双向链表，同时慢指针走到最后一个结点

最后头结点往后走，慢指针往前走（只能用慢指针，因为当结点个数为偶数时，快指针会指向null）进行判断是否回文

public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        //第一步：找到中间结点
        ListNode slow = A;
        ListNode fast = A;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        //第二步：反转中间结点后面的链表
        ListNode cur = slow.next;
        ListNode curN = cur.next;
        while (cur != null) {
            curN = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curN;
        }
        //第三步：判读回文
        while (slow != A) {//当还没有相遇时
            if(A.next==slow&&A.val==slow.val){//偶数个结点回文判断结束条件
                return true;
            }
            if (slow.val != A.val) {//不是回文
                return false;
            }else{//继续判断
                slow=slow.next;
                A=A.next;
            }
        }
        return true;//奇数个结点回文判断结束条件
    }
}

3.

思路：

法一：一个链表作为参照，一个链表用来遍历，如果参照链表的这个结点经过另外那个链表遍历后没有发现相交，参照链表的结点往后，另外那个链表继续遍历，如此类推

法二：如果相交，那么相交之后的链表长度是相同的，所以两个链表长度的差值就等于相交前面的链表长度差值，因此只需要求出两个链表的长度，相减得出差值，让较长的链表先走差值步，然后再以相同的速度往后走，则相等时相交

代码（法一）：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a=headA;
        ListNode b=headB;
        while(a!=null){//每次遍历一个a链表的结点
            while(b!=null){//遍历全部b链表的结点
                if(b==a){//如果相交
                    return b;
                }else{
                    b=b.next;//继续找
                }
            }
            b=headB;//从头开始
            a=a.next;//找下一个结点
        }
        return null;//没有相交
    }
}

代码（法二）：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a=headA;
        ListNode b=headB;
        int len1=0;//a链表的长度
        int len2=0;//b链表的长度
        int len=0;//差值
        while(a!=null){//求a链表的长度
            len1++;
            a=a.next;
        }
        while(b!=null){//求b链表的长度
            len2++;
            b=b.next;
        }
        if(len1>len2){//如果是a链表更长
            len=len1-len2;
            a=headA;//a指向更长的那条链表
            b=headB;//b指向更短的那条链表
        }else{//如果是b链表更长
            len=len2-len1;
            a=headB;//a指向更长的那条链表
            b=headA;//b指向更短的那条链表
        }
        while(len!=0){//让长链表先走差值步
            len--;
            a=a.next;
        }
        while(a!=b){//如果还没有相交
            a=a.next;
            b=b.next;
        }
        if(a==null){//没有相交
            return null;
        }
        return a;//相交点
    }
}

4.

思路：

如果没有环的话，那么一定会有一个尽头，即一定会走到null，如果有环的话，那么将永远没有尽头，即不存在null，这个环可以看作是一个圆形操场，就变为简单的追及相遇这个数学问题，所以需要快慢指针，如果有环，那么快指针一定和慢指针相遇

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null){//如果是空链表
            return false;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){//如果走到了尽头
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){//如果相遇，说明有环
                break;
            }
        }
        if(fast==null||fast.next==null){//如果是因为走到尽头而跳出的循环
            return false;//没有环
        }
        return true;//如果是因为相遇而跳出的循环，则有环
    }
}

5.

思路：

首先判断是否有环，跟上面一题一样，接下来，如果有环，求出环的开始结点，还是快慢指针，快指针一次走两步，慢指针一次走一步，用两个公式表示快慢指针走的路程，其中C是环的长度，K是相遇点距离环的开始结点的长度，X表示头结点到环的开始结点的长度

1.fast走的路程S1：X+NC+C-K

2.slow走的路程S2：X+C-K

并且S1=2S2

所以

X+NC+C-K=2*(X+C-K)

X+NC+C-K=2X+2C-2K

X=(N-1)C+K

由该公式可得，从头结点到环的开始结点等于从相遇点走N-1圈再走到环的开始结点，所以让slow从头结点开始，fast从相遇点开始，以相同的速度开始走，那么再次相遇的位置就是环的开始结点

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null){//如果是空链表
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){//走到尽头
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){//如果相遇
                break;
            }
        }
        if(fast==null||fast.next==null){//如果是因为走到尽头，则无环
            return null;
        }
        //因为相遇，则有环
        slow=head;//从头走到环的开始结点
        while(slow!=fast){//走到相遇
            slow=slow.next;
            fast=fast.next;
        }
        return slow;//返回相遇点（即环的开始结点)
    }
}

6.

思路：

首先先判断特殊情况：两个链表都为空，或者其中一个链表为空，则返回null

然后是正常情况，因为两个链表都是升序的，所以先比较两个链表的头结点，较小的那个结点则一定为两个链表中最小的，所以该结点为合并后新的头结点，然后用一个指针cur去接收两个链表较小的结点，尾插在新的头结点后面，如此类推

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newH=null;//合并后的头结点
        if(list1==null&&list2==null){//两个链表都为空
            return null;
        }
        if(list1==null){//其中一个链表为空
            return list2;
        }
        if(list2==null){//另外一个链表为空
            return list1;
        }
        ListNode a=list1;
        ListNode b=list2;
        if(a.val<b.val){
            newH=a;//说明合并后的新头结点为a链表的头结点
            a=a.next;
        }else{
            newH=b;//说明合并后的新头结点为b链表的头结点
            b=b.next;
        }
        ListNode cur=newH;//用来遍历链表
        while(a!=null&&b!=null){//当两个链表都没有走完
            if(a.val<b.val){//a的小于b，则插a
                cur.next=a;
                cur=cur.next;
                a=a.next;
            }else{//a的大于等于b，则插b
                cur.next=b;
                cur=cur.next;
                b=b.next;
            }
        }
        while(a!=null){//当b链表走完而a链表没有走完，将a链表全部尾插
            cur.next=a;
            cur=cur.next;
            a=a.next;
        }
        while(b!=null){//当a链表走完而b链表没有走完，将b链表全部尾插
            cur.next=b;
            cur=cur.next;
            b=b.next;
        }
        return newH;//返回合并后的新头结点
    }
}