【数据结构】链表相关OJ题【下】

目录

1.合并两个有序链表

2.删除链表中的所有重复元素，不保留

3.删除链表中的重复元素，保留一个

4.分隔链表

5.环形链表

6.返回环形链表的入口节点

7.相交链表

8.移除链表元素

9.反转链表

10.回文链表

11.链表的中间节点

---

1.合并两个有序链表

        要求：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

（1）基础做法

        主要思想：边界条件：一个链表为空，则拼接后一定是那个非空链表；若两个都为空，则返回null；若两个链表都不为空：创建新的虚拟节点，遍历两个链表，将较小的那个链表拼接到这个虚拟节点后 ；若当两个链表中一旦有一个链表遍历完成为null后，则将另一个链表直接拼接到虚拟节点后即可。

         /*//情况1：两个链表都为空:可以省略了，下面的情况2都包含了
        if(list1==null && list2==null){
            return null;
        }
        //情况2：有一个链表为null，则另一个链表就是合并后的链表
        if(list1 == null ){
           return list2;
        }
        if(list2 == null ){
            return list1;
        }
        //情况3：两个链表都不为null
        //(1)创建虚拟头结点
        ListNode dummyHead = new ListNode();
        ListNode tail = dummyHead;
        //(2)遍历两个链表，双指针
        while (list1.next != null && list2.next !=null){
            if(list1.val > list2.val){
                tail.next = list2;//--------注意拼接的是整个链表，并不是链表中的单独节点
                tail = list2;
                list2 = list2.next;
            } else {
                tail.next = list1;
                tail = list1;
                list1 = list1.next;
            }
        }
        //(3)此时说明已经将其中一个链表遍历完，则直接将另一个链表的值全部加到合并链表中
        if(list1 == null){
            tail.next = list2;
        }
        if(list2 == null){
            tail.next = list1;
        }
        //(4)返回最终的头结点
        return dummyHead.next;
    }*/

（2）递归法

 public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //边界条件
        //情况2：有一个链表为null，则另一个链表就是合并后的链表
        if(list1==null ){
            return list2;
        }
        if(list2==null ){
            return list1;
        }
        //递归的使用
        if(list1.val <= list2.val){
            list1.next = mergeTwoLists(list1.next,list2);//此时的list1中的第一个值是最小值，采用递归方法将List1的第一个节点后的所有节点与list2的所有节点合并
            return list1;//list1保存的就是最小值头结点
        } else {
            list2.next = mergeTwoLists(list1.next,list2);//list2中的第一个值是最小值
            return list2;
        }
}

2.删除链表中的所有重复元素，不保留

    public ListNode deleteDuplicates(ListNode head) {
        // 1.base case
        if(head == null || head.next == null) {
            return head;
        }
        if(head.val != head.next.val) {
            head.next = deleteDuplicates(head.next);
            return head;
        }else {
            // 头节点就是重复的节点，先处理完头节点的情况
            ListNode newHead = head.next;
            while(newHead != null && newHead.val == head.val) {
                newHead = newHead.next;
            }
            // 此时newHead一定不是待删除的结点，最终整个传入函数，返回更新后的值即可
            return deleteDuplicates(newHead);
        }
    }

3.删除链表中的重复元素，保留一个

（1）基本做法

        主要思路：双指针法：创建一个虚拟头结点指向链表的头部head，第一个指针从dummyHead开始记作prev，第二个指针从虚拟头结点的下一个位置开始记作cur。 情况1：如果prev和cur的值不相等，说明不是重复的元素，就往后各移动一位； 情况2：如果prev和cur的值相等，说明两者保存的是重复元素，就将prev记录的值进行保留，跳过cur保存的重复值，更改prev的指向为:直接指向cur的下一个节点。同时再更新cur的指向：往后移动一位 。终止条件：cur比prev快一步，所以当cur指向的值为null时，说明遍历结束。

public ListNode deleteDuplicates(ListNode head) {
    //(1)边界条件：只存在一个头结点或者不存在节点时，肯定不存在重复元素，直接返回头结点即可
    if(head==null || head.next == null){
        return head;
    }
    //(2)走到这里最少有两个节点存在
    //创建一个虚拟头结点
    ListNode dummyHead = new ListNode(-101);
    //虚拟头结点添加到当前链表的最开始的头结点
    dummyHead.next = head;
    //创建一个头结点prev代替虚拟头结点从头开始
    ListNode prev = dummyHead;//prev作为第一个指针
    ListNode cur = prev.next;//cur作为第二个指针
    //判断指针的值
    while (cur!=null){
        if(prev.val == cur.val){
            prev = cur.next;
        }else {
            prev = prev.next;
        }
        cur = cur.next;
    }
    //返回链表的头结点
    return dummyHead.next;
}

（2）递归法：先把以head为头结点的子链表的重复元素删除，保留一次（调用递归函数）， 再判断删除后的子链表的头结点与头结点head是否是重复元素，是的话删除head，返回子链表的头部，不是则返回head。

    public ListNode deleteDuplicates(ListNode head) {
        //(1)边界条件
        if(head==null || head.next == null){
            return head;
        }
        //先把以head为头结点的子链表的重复元素删除，保留一次
        head.next = deleteDuplicates(head.next);
        //现在剩下头结点
        return head.val == head.next.val ? head.next : head;
    }

4.分隔链表

        要求：给你一个链表的头节点head和一个特定值 x ，请你对链表进行分隔，使得所有小于x的节点都出现在大于或等于x的节点之前。 你应当保留两个分区中每个节点的初始相对位置。

       主要思路：遍历原链表，将所有小于x节点的放在一个子链表l1，大于x的节点放在子链表l2，最后将l2与l1进行拼接。注意：l2的尾部一定要置为null。

public ListNode partition(ListNode head, int x) {        
        //边界：如果头结点不存在或者只存在一个节点
        if(head ==null || head.next == null){
            return head;
        }
        //产生两个虚拟头结点，并给出节点尾部
        ListNode smallHead = new ListNode();
        ListNode bigHead = new ListNode();
        ListNode smallTial = smallHead;
        ListNode bigTail = bigHead;
        //遍历原链表，将所有小于x的节点尾插到小链表的尾部；相反的尾插到大链表的尾部
        //当head为空时结束遍历
        while (head!=null){
            if(head.val < x){
                smallTial.next = head;
                smallTial = head;
            }else{
                bigTail.next = head;
                bigTail = head;
            }
            head = head.next;
        }
        //结束遍历，将大链表的尾部断开，拼接大小链表
        bigTail.next = null;
        smallTial.next = bigHead.next;
        return smallHead.next;
    }

5.环形链表

        要求：给定一个链表判断该链表中是否有环。

        主要思想：快慢指针：如果存在环，则快指针一定在某一个时刻追上慢指针。如果快指针为null时还没追上，则一定没有环。

 public boolean hasCycle(ListNode head) {
        //定义两个快慢指针
        ListNode low = head;
        ListNode fast = head;
        //当快指针为null时还没相遇，说明没有环
        while (fast !=null && fast.next != null){
            //让快指针每次走两步，慢指针每次走一步
            low = low.next;
            fast = fast.next.next;
            //如果快指针与慢指针相遇了，说明有环
            if(low == fast){
                return true;
            }
        }
        return false;
    }

6.返回环形链表的入口节点

        要求：给定一个具有环的链表，要求返回该环形链表的入口节点。

        主要思想：借助一个结论实现：当快慢指针相遇的时候，引入一个新的节点从链表的头结点开始，最终这个新的节点一定会与慢指针在入口位置相遇。

public ListNode detectCycle(ListNode head) {
        //定义两个快慢指针
        ListNode low = head;
        ListNode fast = head;
        //在快指针没走完的时候
        while (fast!=null && fast.next != null){
            fast = fast.next.next;
            low = low.next;
            if(low == fast){//快慢指针相遇
                ListNode newNode = head;//引入一个新节点
                while (newNode != low){//当慢指针与新节点不相等的时候，让两者一直走
                    low = low.next;
                    newNode = newNode.next;
                }
                //说明慢指针与新节点相遇，此时相遇的位置就是入口
                return newNode;
            }
        }
        return null;
    }

7.相交链表

        要求：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回null。

       思想：使用两个引用listA和listB,同时开始遍历。 如果listA走完了，就走listB，listB也是一样，先走自身，走完了再走listA。如果两者有相交位置，一定在在相交位置相遇；否则当两者都走完还没相遇，就是没有相交节点。

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode l1 = headA;
        ListNode l2 = headB;       
        while (l1 != l2){
            l1 = (l1 == null? headB : l1.next);
            l2 = (l2 == null? headA : l2.next);
        }
        return l1;
    }

8.移除链表元素

        要求：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。

（1）虚拟头结点法：遍历链表，走到被删除节点的前驱，与要删除的值比较，更改指向。

public ListNode removeElements(ListNode head, int val) {    
    //判断边界条件:链表中不存在节点，则直接返回Null
        if(head == null){
            return null;
        }
        //产生一个虚拟头结点
        ListNode dummyNode = new ListNode();
        //将虚拟头结点与原链表建立联系
        dummyNode.next = head;
        //让prev作为临时节点代替head
        ListNode prev = dummyNode;
        while (prev.next != null){
            if(prev.next.val == val){
                prev.next = prev.next.next;
            }else{
                prev = prev.next;//防止出现连续的被删除的节点，只有当prev.next不是被删除的节点时才移动
            }
        }
        return dummyNode.next;
    }

（2）递归法

    public ListNode removeElements(ListNode head, int val) {
        //边界条件
        if(head == null){
            return null;
        }
        //正常情况
        //先把以head.next为头结点的子链表中的所有为val中的值删除完毕！
        head.next = removeElements(head.next,val);
        //最后判断头结点的情况：是否需要删除
        return head.val == val ? head.next:head;
    }

9.反转链表

        要求：输入链表：[1,2,3,4,5]   输出：[5,4,3,2,1]

（1）头插法

        主要思路：先产生一个虚拟头接节点，从head开始不断遍历原链表，每遍历到一个节点，就产生一个与该值相等的新节点， 将该新节点不断头插到虚拟头结点后，最终dummyHead.next就是反转后链表的头结点。

    public ListNode reverseList(ListNode head) {        
        //边界条件：
        if (head == null || head.next == null) {
            return head;
        }
        //产生虚拟头节点
        ListNode dummyHead = new ListNode();
        //遍历原链表，不断产生新节点，将该新节点不断头插到虚拟头结点之后
        while (head != null) {
            ListNode newNode = new ListNode(head.val);
            newNode.next = dummyHead.next;//将新节点与原先的节点相连接
            dummyHead.next = newNode;//将新节点头插到虚拟头结点后
            head = head.next;
        }
        return dummyHead.next;
    }

（2）在原链表移动

    public ListNode reverseList(ListNode head) {
        //边界条件
        if (head == null || head.next == null) {
            return head;
        }
        //让第一个指针指向空，第二个指针指向链表的头，当第二个指针为空的时候结束遍历
        ListNode prev = null;
        ListNode cur = head;
        while (cur!=null){
            //保存第二个指针的下一个指向（因为要对第二个指针进行操作，防止后面的值丢失。）
            ListNode next = cur.next;
            cur.next = prev;//让第二个指针指向第一个指针
            //移动两个指针的位置
            prev = cur;
            cur = next;
        }
        //最终第一个指针指向的值就是头结点
        return prev;
    }

（3）递归法 

     public ListNode reverseList(ListNode head) {
        //边界条件
        if (head == null || head.next == null) {
            return head;
        }
        //处理头节点之后的子链表：进行反转
        ListNode next = head.next;
        ListNode newHead = reverseList(head.next);
        //拼接当前头结点和转后的子链表
        head.next = null;//先断开原先链表头结点之后的节点
        next.next = head;//连接反转后链表的尾部与原先链表的头部
        return newHead;
    }

10.回文链表

        要求：回文链表：1221是，12321是，123312不是回文链表。

        主要思路：比如原链表为12321，将原链表看作两个子链表，以中间节点为其分开：L1: 12, L2: 321——>将L2进行转置结果为123，遍历L1和L2判断两者的值是否相等。在两个子链表为null之前，如果找到任意一个不相等的就返回false。

    public boolean isPalindrome(ListNode head) {     
        //边界条件：链表为null或者只有一个节点都是true
        if(head == null || head.next == null){
            return true;
        }
        //找出链表的中间节点记作middleNode
        ListNode middleNode = middleNode(head);
        //将从middleNode为头结点的链表进行反转后的头结点记作l2
        ListNode l2 = reverseList(middleNode);
        //将以head为头结点的子链表与l2子链表进行遍历判断
        while (head != null & l2!= null){
            //找反例:判断两个子链表的头结点是否相同
            if(head.val != l2.val){
                return false;
            }
            //移动两个子链表头结点的位置
            head = head.next;
            l2 = l2.next;
        }
        return true;
    }
    // 函数目标：找中间节点
    public ListNode middleNode(ListNode head) {
        // 快慢指针法
        ListNode low = head,fast = head;
        while (fast != null && fast.next != null) {
            low = low.next;
            fast = fast.next.next;
        }
        return low;
    }
    // 函数目标：反转链表
    public ListNode reverseList(ListNode head) {
        // 1.base case
        if(head == null || head.next == null) {
            return head;
        }
        ListNode next = head.next;
        ListNode newHead = reverseList(head.next);
        // 拼接当前头结点和转后的子链表
        head.next = null;
        next.next = head;
        return newHead;
    }

11.链表的中间节点

        要求：给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

        思路：快慢指针法。 结论：让第一个和第二个指针都指向头结点，让第一个指针每次走一步，第二指针每次都两步， 当第二个指针走向null的时候，第一个指针所指的位置就是中间节点的位置。

     public ListNode middleNode(ListNode head) {        
        ListNode first = head;
        ListNode second = head;
        while (second!=null && second.next!=null){
            first = first.next;
            second = second.next.next;
        }
        //说明此时第二个指针指向的是Null
        return first;
    }