lc82如果我非要用三个指针的话

大佬们好，
如果这道题我非要用next作为第三个指针的话，是不是真的行不通？
边界条件到底要怎么写啊？head到底怎么动？
这个是很明显的outOfBoundary，我也知道，不过我就想用next指针

下面是我的代码，请大佬赐教

1. public static ListNode deleteDuplicates(ListNode head) {
   
2.                 if(head==null || head.next==null) return head;
   
3.                 ListNode dummy= new ListNode(0);
   
4.                 dummy.next=head;
   
5.                 ListNode pre=dummy;
   
6.                 ListNode next=head.next;
   
7.                 while(head!=null && next!=null ) {
   
8.                         if(head.val==next.val) {
   
9.                                 int samNum=head.val;
   
10.                                 while(next!=null && next.val==samNum) {
    
11.                                         pre.next=next.next;
    
12.                     //这里要保证指针要走，否则无限循环（死循环）
    
13.                     head=pre.next;
    
14.                     next=head.next;
    
15.                                 }
    
16.                         }else {
    
17.                                         pre=head;
    
18.                     //同理，否则无限循环
    
19.                 head=head.next;
    
20.                 next=head.next;
    
21.                                 }
    
22.             // head=head.next;
    
23.                         }
    
24.                 return dummy.next;
    
25.                 }

复制代码

换了个思路，用了三个指针，可是最后尾部出现duplicates的话，fast已经不能进入while循环了
在不改变整体logic下   还有救吗目前问题是：

1. public ListNode deleteDuplicates(ListNode head) {
   
2.         //corner case
   
3.         ListNode dummy= new ListNode(0);
   
4.         dummy.next=head;
   
5.         ListNode pre=dummy;
   
6.         ListNode slow=head;
   
7.         ListNode fast=head;
   
8.         while(fast!=null){
   
9.             //[1,1]不可以
   
10.             //因为fast会出界，导致最后的duplicates进入不了while循环
    
11.             if(pre.val!=slow.val && slow.val== fast.val){
    
12.                 fast=fast.next;
    
13.             }else if(pre.val!=slow.val && slow.val!= fast.val){
    
14.                 if(slow.next!=fast){
    
15.                     pre.next=fast;
    
16.                     slow=fast;
    
17.                     // fast=fast.next;
    
18.                 }else{
    
19.                     pre=slow;
    
20.                     slow=fast;
    
21.                     // fast=fast.next;
    
22.                 }
    
23.                
    
24.             }
    
25.         }
    
26.         return dummy.next;
    
27.     }

复制代码