Leetcode刷题系列java版-----链表(中级)

 在Leetcode刷题系列java版-----链表(简单)中,主要介绍了链表的增删改查和反转链表的基本模板,

下面来看看中级题中如何运用这些模板以及一些比较有意思的题

1.

https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

 思路很简单,就是两个点两个点的取,然后交换即可,但是这里要自己构造一个头指针才好做,不然不太好写。这是链表题常用的技巧之一

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode root = new ListNode();
        root.next = head;
        ListNode r = root;
        while(root.next!=null&&root.next.next!=null){
            ListNode last = root.next;
            ListNode next = root.next.next;
            root.next = root.next.next;
            last.next = next.next;
            next.next = last;
            root = last;
        }
        return r.next;
    }
}

2.

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/

找到相同有重复元素就节点继续循环下去,直到该元素最后一个重复的节点,然后next改一下next指向的对象就行了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null)return null;
        ListNode root = new ListNode();
        root.next = head;
        ListNode r = root;
        while(root.next!=null){
            ListNode t = root.next;
            int f=0;
            while(t.next!=null&&t.val==t.next.val){//发现有重复的值就继续找下一个节点
                t = t.next;
                f=1;
            }
            if(f==1)
                root.next = t.next;//此时的t.next才是要指向的点
            else
                root = root.next;
            
        }
        return r.next;
    }
}

3.

https://leetcode-cn.com/problems/partition-list/

 这题和简单篇中"2.合并两个有序链表"那题用同样的做法也能做出来,这里不多解释只贴代码做个记录

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode small = new ListNode();
        ListNode big = new ListNode();
        ListNode root = small;
        ListNode rootbig = big;
        while(head!=null){
            if(head.val<x){
                small.next = head;
                small = small.next;
            }else{
                big.next = head;
                big = big.next;
            }
            head = head.next;
        }
        big.next = null;
        small.next = rootbig.next;
        return root.next;
    }
}

4.

https://leetcode-cn.com/problems/reorder-list/

这题的意思是整个链表收尾分别相连,两两配对,形成新的链表,L0指向Ln,L1指向Ln-1,稍微观察一下规律很容易想到可以把后半部分的链表反转,然后用两个指针,一个指向0,另一个指向n/2,这样就可以实现O(n)的复杂度快速连接配对,求出新的链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        int len=0;
        ListNode root = head;
        //先求出链表的长度为len
        while(head!=null){
            len++;
            head = head.next;
        }
        head = root;
        int step = len/2;
        for(int i=0;i<len/2;i++){
            root = root.next;
        }
        //进行反转链表的操作
        ListNode pre = null;
        ListNode now = root;
        while(now!=null){
            ListNode ne = now.next;
            now.next = pre;
            pre = now;
            now = ne;
        }

        //开始拼接链表元素
        ListNode first = head;
        ListNode second = pre;
        ListNode nowfirst=first;
        ListNode nowsecond = second;
        while(first!=null&&second!=null){
            nowfirst=first;
            nowsecond = second;
            first = first.next;
            second = second.next;
            nowfirst.next = nowsecond;
            nowsecond.next = first;
        }
        nowsecond.next = null;//一定要记得判空,不然会形成环

        //后半段链表可能会多出来一个元素,需要特判一下
        if(second!=null){
            nowsecond.next = second;
            nowsecond.next.next =null;//一定要记得判空,不然会形成环
        }
        
    }
}