【剑指offer】链表刷题

方法总结

快慢指针、三指针、哈希表

JZ6 从尾到头打印链表

输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

例：

输入：{1,2,3}

返回值：[3,2,1]

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

JZ24 反转链表

给定一个单链表的头结点pHead(该头节点是有值的)，长度为n，反转该链表后，返回新链表的表头。

例：

输入：{1,2,3}

返回值：{3,2,1}

import java.util.*;

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

public class Solution {
    public ListNode ReverseList (ListNode head) {
        // write code here
        ListNode newHead = null;
        while(head != null){
            ListNode temp = head.next;
            head.next = newHead;
            newHead = head;
            head = temp;
        }
        return newHead;
    }
}

JZ25 合并两个排序的链表

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

例：

输入：{1,3,5},{2,4,6}

返回值：{1,2,3,4,5,6}

import java.util.*;

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

public class Solution {
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        if(pHead1 == null && pHead2 == null){
            return null;
        }
        ListNode myList = new ListNode(0);
        ListNode newNode = myList;
        while(pHead1 != null && pHead2 != null){
            int key;
            if(pHead1.val <= pHead2.val){
                key = pHead1.val;
                pHead1 = pHead1.next;
            }else{
                key = pHead2.val;
                pHead2 = pHead2.next;
            }
            ListNode node = new ListNode(key);
            newNode.next = node;
            newNode = newNode.next;
        }
        if(pHead1 != null) newNode.next = pHead1;
        if(pHead2 != null) newNode.next = pHead2;

        return myList.next;
    }
}

JZ52 两个链表的第一个公共结点

输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。

例：

输入：{1,2,3},{4,5},{6,7}

返回值：{6,7}

说明：第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分，这3个参数最后在后台会组装成为两个无环的单链表，且是有公共节点的。

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null || pHead2 == null){
            return null;
        }
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;

        while(p1 != p2){
            p1 = p1 == null ? pHead2 : p1.next;
            p2 = p2 == null ? pHead1 : p2.next;
        }
        return p1;
    }
}

JZ23 链表中环的入口结点

给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。

例：

输入：{1,2},{3,4,5}

返回值：3

说明：返回环形链表入口结点，我们后台程序会打印该环形链表入口结点对应的结点值，即3。

import java.util.*;
/*
 public class ListNode {
    int val;
    ListNode next = null;

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

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        HashSet<ListNode> set = new HashSet<>();
        while(pHead != null){
            if(set.contains(pHead)){
                return pHead;
            }
            set.add(pHead);
            pHead = pHead.next;
        }
        return null;
    }
}

JZ22 链表中倒数最后k个结点

输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。如果该链表长度小于k，请返回一个长度为 0 的链表。

例：

输入：{1,2,3,4,5},2

返回值：{4,5}

说明：返回倒数第2个节点4，系统会打印后面所有的节点来比较。

import java.util.*;

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

public class Solution {
    public ListNode FindKthToTail (ListNode pHead, int k) {
        ListNode fast = pHead;
        for(int i=0; i<k; i++){
            if(fast == null){
                return null;
            }
            fast = fast.next;
        }
        ListNode slow = pHead;
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

JZ35 复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）。

例：

输入：{1,2,3,4,5,3,5,#,2,#}

返回值：{1,2,3,4,5,3,5,#,2,#}

说明：我们将链表分为两段，前半部分{1,2,3,4,5}为ListNode，后半部分{3,5,#,2,#}是随机指针域表示。以上示例前半部分可以表示链表为的ListNode:1->2->3->4->5。后半部分，3，5，#，2，#分别的表示为1的位置指向3，2的位置指向5，3的位置指向null，4的位置指向2，5的位置指向null

import java.util.*;
/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        //使用hashMap来存放随意指针的对应关系
        Map<RandomListNode, RandomListNode> map = new HashMap<>();
        RandomListNode p = pHead;
        //先将所有节点复制一遍，并保存映射关系
        while(p != null){
            RandomListNode node = new RandomListNode(p.label);
            map.put(p, node);
            p = p.next;
        }
        //再遍历一遍，处理好指针问题
        p = pHead;
        while(p != null){
            RandomListNode node = map.get(p);//得到新节点
            if(p.next == null){
                node.next = null;
            }else{
                node.next = map.get(p.next);
            }
            node.next = (p.next == null)? null:map.get(p.next);
            node.random = (p.random == null)? null:map.get(p.random);
            p = p.next;
        }
        //返回新的链表头结点
        return map.get(pHead);
    }
}

JZ76 删除链表中重复的结点

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

例：

输入：{1,1,1,8}

返回值：{8}

方法一

import java.util.*;
/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        ListNode res = new ListNode(0);
        res.next = pHead;
        ListNode pre = res;
        ListNode cur = pHead;
        boolean flag = false;
        while(cur != null){
            if (cur.next != null && cur.val == cur.next.val) {
                while(cur.next != null && cur.val == cur.next.val){
                    cur = cur.next;
                }
                pre.next = cur.next;
                cur = cur.next;
            }else{
                pre = pre.next;
                cur = cur.next;
            }
        }
        return res.next;
    }
}

方法二：哈希表（哈希表常用来统计频率、快速检验某个元素是否出现过等）

import java.util.*;
/*
 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;
        }
        Map<Integer, Integer> mp = new HashMap<>();
        ListNode cur = pHead;
        while(cur != null){
            if(mp.containsKey(cur.val)){
                mp.put(cur.val, (int)mp.get(cur.val)+1);
            }else{
                mp.put(cur.val, 1);
            }
            cur = cur.next;
        }
        ListNode res = new ListNode(0);
        res.next = pHead;
        cur = res;
        while(cur.next != null){
            if(mp.get(cur.next.val) > 1){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
            
        }
        return res.next;
    }
}

JZ18 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

例：

输入：{2,5,1,9},5

返回值：{2,1,9}

import java.util.*;

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

public class Solution {

    public ListNode deleteNode (ListNode head, int val) {
        ListNode res = new ListNode(0);
        res.next = head;
        ListNode pre = res;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
                break;
            }
            pre = pre.next;
            cur = cur.next;
        }
        return res.next;
    }
}