剑指offer之链表

从尾到头打印链表

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
思路1：
递归 时间复杂度 On空间复杂度On

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

思路二：调用链表得函数时间复杂度 On空间复杂度On

/**
*    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 list = new ArrayList<>();
        while (listNode!=null){
            list.add(0,listNode.val);
            listNode = listNode.next;
        }
        return list; 
    }
}

思路三：运用栈后进先出得特性，先使链表所有结点顺序入栈，最后一个进去得最先出栈。时间复杂度On空间On

/**
*    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) {

        Stack stack = new Stack<>();
        ArrayList list = new ArrayList<>();
        while (listNode!=null){
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while (!stack.isEmpty()){
            list.add(stack.pop());
        }
        return list;
}

链表中环得入口节点

题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
思路：链接：
1.用两个指针一快一慢走，直到两个指针相等。此时指针指向圈内某一结点
2.其中一个指针走，直到回到原节点，记录圈的大小n。
3.两个指针从头节点开始，其中一个指针先走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 || pHead.next==null){
            return null;
        }
        int flag = 0;
        ListNode f = pHead,l = pHead;
        while (f!=null||f.next!=null){
            l = l.next;
            f = f.next.next;
            if (l==f){
                flag = 1;
                break;
            }
        }
        if (flag==0){
            return null;
        }else{
            l = l.next;
            int n = 1;
            while (l!=f) {
                l = l.next;
                n++;
            }
            l = f = pHead;
            for (int i=0;i<n;i++){
                l = l.next;
            }
            while(l!=f){
                l = l.next;
                f = f.next;
            }
            return l;
        }
    }
}

删除链表中重复的节点

题目描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路1：多次遍历，第一次遍历把重复的结点值存入 set 容器，第二次遍历，当结点值存储在 set 容器中，就删除该结点
时间复杂度：HashSet 是基于哈希表实现的，查找效率为 O(1)，所以总的效率是 O(n)
空间复杂度：最坏的情况是存一半结点 O(n/2)，最好的情况是一个也不存，O(1)

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

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

public ListNode deleteDuplication(ListNode pHead){
        if(pHead == null){
            return  null;
        }
        // 先找出相同结点，存入 set
        HashSet<Integer> set = new HashSet<>();
        ListNode pre = pHead;
        ListNode cur = pHead.next;
        while(cur != null){
            if(cur.val == pre.val){
                set.add(cur.val);
            }
            pre = cur;
            cur = cur.next;
        }
        // 再根据相同节点删除
        // 先删头部
        while(pHead != null && set.contains(pHead.val)){
            pHead = pHead.next;
        }
        if(pHead == null){
            return null;
        }
        // 再删中间结点
        pre = pHead;
        cur = pHead.next;
        while(cur != null){
            if(set.contains(cur.val)){
                pre.next = cur.next;
                cur = cur.next;
            }else{
                pre = cur;
                cur = cur.next;
            }
        }
        return pHead;
    }
}

思路2：链接：
借助辅助头结点，可避免单独讨论头结点的情况。设置两个结点 pre 和 cur，当 cur 和 cur.next 值相等，cur 一直向前走，直到不等退出循环，这时候 cur 指的值还是重复值，调整 cur 和 pre 的指针再次判断、
时间复杂度：O(n)
空间复杂度：O(1)

链接：https://www.nowcoder.com/questionTerminal/fc533c45b73a41b0b44ccba763f866ef?answerType=1&f=discussion
来源：牛客网

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;
    }
}