链表双指针经典习题

删除排序链表中的重复元素（

双指针，一个在前一个在后，如果值相等则进行删除操作。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
            ListNode dummy=new ListNode(-2,head);
            ListNode p1=dummy;
            ListNode p2=head;
            while(p2!=null){
                if(p1.val==p2.val){
                    p1.next=p2.next;
                    p2=p2.next;
                }else{
                    p1=p1.next;
                    p2=p2.next;
                }
            }
            return dummy.next;
    }
}

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy=new ListNode(-1,head);
        ListNode p1=dummy,p2=head;
        while(p2!=null){
            if(p2.next!=null&&p2.val==p2.next.val){//发现重复节点
                while(p2.next!=null&&p2.val==p2.next.val){
                    p2=p2.next;
                }
                p1.next=p2.next;
            }else{
                p1=p1.next;
            }
            p2=p2.next;
        }
        return dummy.next;
    }
}

丑数

三个指针，指向2 3 5因子的链

P指向丑数链，用于构建丑数

每次存入最小值，指针再向前移动，

如果取得是因子为2的丑数，则product2更新，指针++

class Solution {
    public int nthUglyNumber(int n) {
        int p1=1,p2=1,p3=1;//指针
        int product2=1,product3=1,product5=1;//分别是因子为 2 3 5的丑数
        int p=1;//指向丑数数组的指针
        int[] ugly=new int[n+1];//存丑数
        while(p<=n){
            int min=Math.min(product2,Math.min(product3,product5));
            ugly[p]=min;
            p++;
            if(min==product2){
                product2=2*ugly[p1];
                p1++;
            }
            if(min==product3){
                product3=3*ugly[p2];
                p2++;
            }
            if(min==product5){
                product5=5*ugly[p3];
                p3++;
            }
        }
        return ugly[n];
    }
}

有序矩阵中第k个小的数

用优先队列，最小堆存放 数值，和行列

每次弹出一个最小值，k—弹出一个再补一个 该行的下一个最小值

class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        PriorityQueue<int[]> pq=new PriorityQueue<>((a,b)->(a[0]-b[0]));
        for(int i=0;i<matrix.length;i++){//遍历行
            pq.add(new int[]{matrix[i][0],i,0});//新建一个数组存放值和，行列的信息，放最小
        }
        while(!pq.isEmpty()&&k>0){
            int[] x=pq.poll();
            k--;
            if(k==0) return x[0];
            int i=x[1],j=x[2];//行列
            if(j+1<matrix[i].length){
                pq.add(new int[]{matrix[i][j+1],i,j+1});//存入该行下一个元素
            }
        }
        return -1;
    }   
}

有序矩阵中第k个小的数

用优先队列，最小堆存放 数值，和行列

每次弹出一个最小值，k—弹出一个再补一个 该行的下一个最小值

class Solution {
    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        PriorityQueue<int[]> pq=new PriorityQueue<>((a,b)->(a[0]+a[1]-(b[0]+b[1])));//数组对排序
        for(int i=0;i<nums1.length;i++){
            pq.add(new int[]{nums1[i],nums2[0],0});//nums2的第0个
        }
        List<List<Integer>> res=new ArrayList<>();
        while(!pq.isEmpty()){//每次循环都是新的路径
            int[] x=pq.poll();
            k--;
            int index=x[2]+1;
            if(index<nums2.length){
                pq.add(new int[]{x[0],nums2[index],index});
            }
            List<Integer> path=new ArrayList<>();
            path.add(x[0]);
            path.add(x[1]);
            res.add(path);
            if(k==0) break;
        }
        return res;
    }
}