【剑指offer】链表篇

题目一：链表中环的入口结点

问题：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路
在链表中若有环形成，一定是在链尾，解题步骤：

1. 判断链表中有环:利用两个指针 l、r，l走一步r走两步，若有环，则一定会在环中相遇（可用数学方法进行证明），用flag进行标记；
2. 得到环中节点的数目，遍历环即可；
3. 找到环中的入口节点，类似找出倒数第k个节点，先让一个指针走n步，然后再同时走，相遇的节点就是环的入口点。 --很巧妙–

代码

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead==null){
            return null;
        }
        //判断是否有环
        ListNode l=pHead,r=pHead;
        boolean flag=false;
        while(r!=null&&r.next!=null){
            l=l.next;
            r=r.next.next;
            if(l==r){
                flag=true;
                break;
            }
        }
        //计算环长
        if(!flag){
            return null;
        }else{
            int n=1;
            r=r.next;
            while(r!=l){
                r=r.next;
                n++;
            }
            //寻找入口节点
            l=pHead;
            r=pHead;
            for(int i=0;i<n;i++){
                r=r.next;
            }
            while(r!=l){
                l=l.next;
                r=r.next;
            }
            return r;
        }

    }
}

题目二：删除链表中重复结点

问题：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

思路
借助辅助头结点，避免单独讨论头结点的情况。
设置两个结点 pre 和 cur，判断cur 和 cur.next 的值，分两种情况进行 pre 和 cur指针的移动。

代码

public class Solution {
    public ListNode deleteDuplication(ListNode pHead){
        if(pHead == null || pHead.next == null){
            return pHead;
        }
        // 自己构建辅助头结点
        ListNode head = new ListNode(Integer.MIN_VALUE);
        head.next = pHead;
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.next != null && cur.next.val == cur.val){
                // 相同结点一直前进
                while(cur.next != null && cur.next.val == cur.val){
                    cur = cur.next;
                }
                // 退出循环时，cur 指向重复值，也需要删除，而 cur.next 指向第一个不重复的值
                // cur 继续前进
                cur = cur.next;
                // pre 连接新结点
                pre.next = cur;
            }else{
                pre = cur;
                cur = cur.next;
            }
        }
        return head.next;
    }
}

若重复结点保留：

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        ListNode l=pHead,r;
        ListNode h=pHead;
        while(l.next!=null){
            r=l.next;
            while(l.val==r.val){
                l.next=r.next;
                r=r.next;
            }
            l=r;
        }
        return h;
    }
}

题目三：从尾到头打印链表

问题：输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

思路一
先进后出，非递归法我们可以想到栈（在同一个口插入、取出）。
ArrayList 中有个方法是 add(index,value)，可以指定 index 位置插入 value 值
所以我们在遍历 ListNode 的同时将每个遇到的值插入到 list 的 0 位置，最后输出 ListNode 即可得到逆序链表。

代码

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();
        ListNode temp=listNode;
        while(temp!=null){
            list.add(0,temp.val);
            temp=temp.next;
        }
        return list;
    }
}

思路二
递归法 借助系统栈，从链表的尾到头添加到ArrayList中。

代码

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    ArrayList<Integer> list = new ArrayList();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode!=null){
            printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}